pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/ios/Sources/PythonNativeKit/Screens/PNViewController.swift

@@ -0,0 +1,237 @@
+import UIKit
+
+/// Hosts one PythonNative screen.
+///
+/// Lifecycle is forwarded to Python as `callback("host", screenId,
+/// event, payload)`: `create` (viewDidLoad), `start`, `layout`,
+/// `resume`, `pause`, `stop`, `destroy`, `save_state`, and
+/// `restore_state`. Python attaches its root view with
+/// `Host.attach_root`; the controller keeps that view below the top
+/// safe-area inset and full-bleed at the bottom. Fast Refresh needs no
+/// help from here: the Python dev client reloads modules and refreshes
+/// the mounted screens itself.
+open class PNViewController: UIViewController {
+    /// Dotted path of the screen component (`nil` = the app entry module).
+    public var requestedScreenPath: String?
+    /// JSON-encoded screen args, or `nil`.
+    public var requestedScreenArgsJSON: String?
+    /// State JSON to hand to Python right after `create` (from a prior `saveState`).
+    public var restoredStateJSON: String?
+    public var cachedStateJSON: String?
+
+    /// The id Python uses to address this screen.
+    public private(set) var screenId: Int64 = 0
+    /// Whether `create` has been sent (and not refused by a bootstrap error).
+    public private(set) var isScreenCreated = false
+
+    private(set) var rootView: UIView?
+    private var lastLayoutPayload: String?
+
+    /// The application host can instantiate its controller subclass dynamically.
+    public required override init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: Bundle?) {
+        super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
+        screenId = PNScreenRegistry.shared.register(self)
+    }
+
+    public required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        screenId = PNScreenRegistry.shared.register(self)
+    }
+
+    deinit {
+        if isScreenCreated {
+            PNBridge.shared.callPython(kind: "host", tag: screenId, name: "destroy", payload: "{}")
+        }
+        PNScreenRegistry.shared.unregister(screenId)
+    }
+
+    // MARK: - Subclass hooks
+
+    /// Called from `viewDidLoad` before the screen is created. Return
+    /// `false` (after showing an error) to skip creating the screen.
+    open func prepareRuntime() -> Bool {
+        true
+    }
+
+    /// The screen path used when `requestedScreenPath` is `nil`.
+    open var defaultScreenPath: String {
+        (Bundle.main.object(forInfoDictionaryKey: "PNEntryModule") as? String) ?? "app.main"
+    }
+
+    // MARK: - Lifecycle
+
+    open override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .systemBackground
+        guard prepareRuntime() else { return }
+        guard PNBridge.shared.hasCallback else {
+            showBootstrapError("The Python bridge callback is not registered.\n\nImport pythonnative.bridge after starting the interpreter.")
+            return
+        }
+        isScreenCreated = true
+        var payload: [String: Any] = [
+            "path": requestedScreenPath ?? defaultScreenPath,
+            "args": requestedScreenArgsJSON ?? NSNull(),
+        ]
+        if let restored = restoredStateJSON {
+            payload["restored_state"] = restored
+        }
+        PNBridge.shared.callPython(kind: "host", tag: screenId, name: "create", payload: PNJSON.encode(payload))
+        if let restored = restoredStateJSON {
+            PNBridge.shared.callPython(kind: "host", tag: screenId, name: "restore_state", payload: restored)
+        }
+    }
+
+    open override func viewWillAppear(_ animated: Bool) {
+        super.viewWillAppear(animated)
+        forward("start")
+    }
+
+    open override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+        syncRootFrame()
+        let payload = viewportJSON()
+        // Every pass forwards (rotation, multitasking, keyboard), but a
+        // pass that changed nothing about the viewport is skipped.
+        if payload != lastLayoutPayload {
+            lastLayoutPayload = payload
+            forward("layout", payload)
+        }
+    }
+
+    open override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        syncRootFrame()
+        forward("resume", viewportJSON())
+    }
+
+    open override func viewWillDisappear(_ animated: Bool) {
+        super.viewWillDisappear(animated)
+        forward("pause")
+    }
+
+    open override func viewDidDisappear(_ animated: Bool) {
+        super.viewDidDisappear(animated)
+        forward("stop")
+    }
+
+    open override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
+        super.traitCollectionDidChange(previousTraitCollection)
+        if previousTraitCollection?.userInterfaceStyle != traitCollection.userInterfaceStyle {
+            lastLayoutPayload = nil
+            view.setNeedsLayout()
+        }
+    }
+
+    /// Ask Python for the screen's serialized state (`save_state`).
+    @discardableResult
+    public func saveState() -> String? {
+        guard isScreenCreated else { return nil }
+        PNBridge.shared.callPython(kind: "host", tag: screenId, name: "save_state", payload: "{}")
+        return cachedStateJSON
+    }
+
+    /// Hand previously saved state back to Python (`restore_state`).
+    public func restoreState(_ json: String) {
+        guard isScreenCreated else {
+            restoredStateJSON = json
+            return
+        }
+        PNBridge.shared.callPython(kind: "host", tag: screenId, name: "restore_state", payload: json)
+    }
+
+    open override var prefersStatusBarHidden: Bool { PNStatusBarState.hidden }
+    open override var preferredStatusBarStyle: UIStatusBarStyle { PNStatusBarState.style }
+    open override var preferredStatusBarUpdateAnimation: UIStatusBarAnimation { PNStatusBarState.animation }
+
+    private func forward(_ event: String, _ payload: String = "{}") {
+        guard isScreenCreated else { return }
+        PNBridge.shared.callPython(kind: "host", tag: screenId, name: event, payload: payload)
+    }
+
+    // MARK: - Root view
+
+    /// Attach Python's root view (`Host.attach_root`).
+    func attachRoot(_ root: UIView) {
+        if rootView !== root {
+            rootView?.removeFromSuperview()
+        }
+        rootView = root
+        root.translatesAutoresizingMaskIntoConstraints = true
+        root.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        view.addSubview(root)
+        syncRootFrame()
+    }
+
+    /// Detach the root view (`Host.detach_root`).
+    func detachRoot(_ root: UIView) {
+        if root.superview === view {
+            root.removeFromSuperview()
+        }
+        if rootView === root {
+            rootView = nil
+        }
+    }
+
+    /// The frame the root occupies: below the top inset, full-bleed at
+    /// the bottom so a tab bar can reach the home indicator.
+    public var rootFrame: CGRect {
+        let bounds = view.bounds
+        let insets = view.safeAreaInsets
+        let w = max(0, bounds.width - insets.left - insets.right)
+        let h = max(0, bounds.height - insets.top)
+        if w > 0, h > 0 {
+            return CGRect(x: insets.left, y: insets.top, width: w, height: h)
+        }
+        return bounds
+    }
+
+    private func syncRootFrame() {
+        guard let root = rootView else { return }
+        let frame = rootFrame
+        if root.frame != frame {
+            root.frame = frame
+        }
+    }
+
+    /// The `{"width","height","insets","color_scheme"}` payload shared by
+    /// `layout`, `resume`, and `Host.viewport`.
+    public func viewport() -> [String: Any] {
+        var frame = rootFrame
+        if frame.width <= 0 || frame.height <= 0 {
+            frame = PNWindow.screenBounds()
+        }
+        let insets = view.safeAreaInsets
+        return [
+            "width": Double(frame.width),
+            "height": Double(frame.height),
+            "insets": [
+                "top": 0.0,
+                "left": Double(insets.left),
+                "bottom": Double(insets.bottom),
+                "right": Double(insets.right),
+            ],
+            "color_scheme": PNWindow.colorScheme(for: view),
+        ]
+    }
+
+    func viewportJSON() -> String {
+        PNJSON.encode(viewport())
+    }
+
+    // MARK: - Bootstrap error UI
+
+    /// Replace the screen with a full-bleed error report.
+    public func showBootstrapError(_ message: String) {
+        PNLog.screens.error("\(message)")
+        let text = UITextView(frame: view.bounds)
+        text.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        text.isEditable = false
+        text.backgroundColor = UIColor(red: 0.75, green: 0.10, blue: 0.10, alpha: 1.0)
+        text.textColor = .white
+        text.font = UIFont.monospacedSystemFont(ofSize: 13, weight: .regular)
+        text.textContainerInset = UIEdgeInsets(top: 60, left: 16, bottom: 40, right: 16)
+        text.text = "PythonNative could not start\n\n\(message)"
+        view.addSubview(text)
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Support/PNCompat.swift

@@ -0,0 +1,46 @@
+import CoreLocation
+import Photos
+import UIKit
+
+/// Back-deployment shims for APIs that moved or appeared after iOS 13, so
+/// the kit compiles at the lowest deployment target `pn` accepts.
+extension CLLocationManager {
+    /// `authorizationStatus` (instance, iOS 14+) with the class-method
+    /// fallback used on iOS 13.
+    var pnAuthorizationStatus: CLAuthorizationStatus {
+        if #available(iOS 14.0, *) {
+            return authorizationStatus
+        }
+        return CLLocationManager.authorizationStatus()
+    }
+}
+
+extension PHPhotoLibrary {
+    /// Read/write library access status on iOS 14+, the legacy status before.
+    static func pnReadWriteAuthorizationStatus() -> PHAuthorizationStatus {
+        if #available(iOS 14.0, *) {
+            return authorizationStatus(for: .readWrite)
+        }
+        return authorizationStatus()
+    }
+
+    /// Request read/write library access with the API available on this OS.
+    static func pnRequestReadWriteAuthorization(_ handler: @escaping (PHAuthorizationStatus) -> Void) {
+        if #available(iOS 14.0, *) {
+            requestAuthorization(for: .readWrite, handler: handler)
+        } else {
+            requestAuthorization(handler)
+        }
+    }
+}
+
+extension UIDatePicker {
+    /// Prefer the compact inline style where the OS offers it.
+    func pnApplyCompactStyle() {
+        if #available(iOS 14.0, *) {
+            preferredDatePickerStyle = .compact
+        } else if #available(iOS 13.4, *) {
+            preferredDatePickerStyle = .wheels
+        }
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Support/PNJSON.swift

@@ -0,0 +1,173 @@
+import Foundation
+
+/// JSON helpers shared by the bridge, event emitters, and modules.
+///
+/// Encoding tolerates values `JSONSerialization` rejects (non-finite
+/// doubles, `Optional.none`, `CGFloat`, `URL`) by normalizing them
+/// first; decoding turns the Python-side `"inf"` marker back into
+/// `Double.infinity`.
+public enum PNJSON {
+    /// Decode a JSON document into Foundation containers.
+    public static func decode(_ text: String) -> Any? {
+        guard let data = text.data(using: .utf8) else { return nil }
+        return try? JSONSerialization.jsonObject(with: data, options: [.fragmentsAllowed])
+    }
+
+    /// Decode a JSON object, returning an empty dictionary for anything else.
+    public static func decodeObject(_ text: String?) -> [String: Any] {
+        guard let text = text, let value = decode(text) as? [String: Any] else { return [:] }
+        return value
+    }
+
+    /// Encode any JSON-compatible value (a fragment is allowed).
+    public static func encode(_ value: Any?) -> String {
+        let normalized = normalize(value)
+        guard JSONSerialization.isValidJSONObject([normalized]) else { return "null" }
+        guard let data = try? JSONSerialization.data(withJSONObject: normalized, options: [.fragmentsAllowed]),
+              let text = String(data: data, encoding: .utf8)
+        else {
+            return "null"
+        }
+        return text
+    }
+
+    /// Replace every `"inf"` string in a decoded prop tree with `Double.infinity`.
+    public static func resolveInfinity(_ value: Any) -> Any {
+        if let string = value as? String {
+            return string == "inf" ? Double.infinity : string
+        }
+        if let dict = value as? [String: Any] {
+            var out: [String: Any] = [:]
+            out.reserveCapacity(dict.count)
+            for (key, item) in dict {
+                out[key] = resolveInfinity(item)
+            }
+            return out
+        }
+        if let array = value as? [Any] {
+            return array.map { resolveInfinity($0) }
+        }
+        return value
+    }
+
+    /// Convert arbitrary values to something `JSONSerialization` accepts.
+    static func normalize(_ value: Any?) -> Any {
+        guard let value = value else { return NSNull() }
+        switch value {
+        case let optional as Optional<Any>:
+            guard let unwrapped = optional else { return NSNull() }
+            return normalizeConcrete(unwrapped)
+        default:
+            return normalizeConcrete(value)
+        }
+    }
+
+    private static func normalizeConcrete(_ value: Any) -> Any {
+        switch value {
+        case is NSNull:
+            return value
+        case let bool as Bool:
+            return bool
+        case let double as Double:
+            return double.isFinite ? double : NSNull()
+        case let float as Float:
+            return float.isFinite ? Double(float) : NSNull()
+        case let cg as CGFloat:
+            return cg.isFinite ? Double(cg) : NSNull()
+        case let int as Int:
+            return int
+        case let int64 as Int64:
+            return int64
+        case let number as NSNumber:
+            return number
+        case let string as String:
+            return string
+        case let url as URL:
+            return url.absoluteString
+        case let dict as [String: Any]:
+            var out: [String: Any] = [:]
+            out.reserveCapacity(dict.count)
+            for (key, item) in dict {
+                out[key] = normalize(item)
+            }
+            return out
+        case let array as [Any]:
+            return array.map { normalize($0) }
+        default:
+            return String(describing: value)
+        }
+    }
+}
+
+/// Typed accessors for loosely typed prop dictionaries.
+public enum PNProps {
+    /// Coerce numbers, numeric strings, and the `"inf"` marker to `Double`.
+    public static func double(_ value: Any?) -> Double? {
+        switch value {
+        case let d as Double: return d
+        case let f as Float: return Double(f)
+        case let cg as CGFloat: return Double(cg)
+        case let i as Int: return Double(i)
+        case let n as NSNumber: return n.doubleValue
+        case let s as String:
+            if s == "inf" { return Double.infinity }
+            if s == "-inf" { return -Double.infinity }
+            return Double(s)
+        default: return nil
+        }
+    }
+
+    /// Like `double(_:)` but non-finite values fall back to `fallback`.
+    public static func finite(_ value: Any?, _ fallback: Double = 0) -> Double {
+        guard let d = double(value), d.isFinite else { return fallback }
+        return d
+    }
+
+    public static func int(_ value: Any?) -> Int? {
+        switch value {
+        case let i as Int: return i
+        case let n as NSNumber: return n.intValue
+        case let d as Double: return d.isFinite ? Int(d) : nil
+        case let s as String: return Int(s) ?? Double(s).map { Int($0) }
+        default: return nil
+        }
+    }
+
+    public static func bool(_ value: Any?) -> Bool? {
+        switch value {
+        case let b as Bool: return b
+        case let n as NSNumber: return n.boolValue
+        case let s as String: return s.lowercased() == "true"
+        default: return nil
+        }
+    }
+
+    public static func string(_ value: Any?) -> String? {
+        switch value {
+        case nil: return nil
+        case is NSNull: return nil
+        case let s as String: return s
+        case let n as NSNumber: return n.stringValue
+        default: return String(describing: value as Any)
+        }
+    }
+
+    public static func dict(_ value: Any?) -> [String: Any]? {
+        value as? [String: Any]
+    }
+
+    public static func array(_ value: Any?) -> [Any]? {
+        value as? [Any]
+    }
+
+    /// True when the key is present, even if its value is `null`.
+    public static func has(_ props: [String: Any], _ key: String) -> Bool {
+        props.index(forKey: key) != nil
+    }
+
+    /// The value for `key`, treating JSON `null` as absent.
+    public static func value(_ props: [String: Any], _ key: String) -> Any? {
+        guard let v = props[key], !(v is NSNull) else { return nil }
+        return v
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Support/PNLog.swift

@@ -0,0 +1,47 @@
+import Foundation
+import os.log
+
+/// A thin `os_log` wrapper with the subset of the `Logger` API the kit
+/// uses. `Logger` itself is iOS 14+, and apps may set a deployment target
+/// as low as iOS 13, so this keeps the kit buildable at the app's minimum.
+struct PNLogger {
+    let log: OSLog
+
+    init(category: String) {
+        log = OSLog(subsystem: "com.pythonnative", category: category)
+    }
+
+    func error(_ message: String) { os_log("%{public}@", log: log, type: .error, message) }
+    func warning(_ message: String) { os_log("%{public}@", log: log, type: .default, message) }
+    func info(_ message: String) { os_log("%{public}@", log: log, type: .info, message) }
+    func debug(_ message: String) { os_log("%{public}@", log: log, type: .debug, message) }
+}
+
+/// Loggers for every PythonNativeKit subsystem, plus a rate limiter for
+/// messages that could otherwise fire at frame rate.
+enum PNLog {
+    static let bridge = PNLogger(category: "bridge")
+    static let components = PNLogger(category: "components")
+    static let gestures = PNLogger(category: "gestures")
+    static let animation = PNLogger(category: "animation")
+    static let modules = PNLogger(category: "modules")
+    static let screens = PNLogger(category: "screens")
+
+    private static var lastEmitted: [String: TimeInterval] = [:]
+    private static var onceKeys: Set<String> = []
+
+    /// Log `message` at most once per `interval` seconds for a given `key`.
+    static func rateLimited(_ logger: PNLogger, key: String, interval: TimeInterval = 1.0, _ message: @autoclosure () -> String) {
+        let now = Date().timeIntervalSinceReferenceDate
+        if let last = lastEmitted[key], now - last < interval { return }
+        lastEmitted[key] = now
+        logger.error(message())
+    }
+
+    /// Log `message` exactly once per process for a given `key`.
+    static func once(_ logger: PNLogger, key: String, _ message: @autoclosure () -> String) {
+        if onceKeys.contains(key) { return }
+        onceKeys.insert(key)
+        logger.warning(message())
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Support/PNWindow.swift

@@ -0,0 +1,51 @@
+import UIKit
+
+/// Window and presenter lookups shared by modals, alerts, pickers, and portals.
+public enum PNWindow {
+    /// The app's key window (scene-based lookup, no deprecated APIs).
+    public static func keyWindow() -> UIWindow? {
+        let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+        for scene in scenes where scene.activationState == .foregroundActive {
+            if let window = scene.windows.first(where: { $0.isKeyWindow }) { return window }
+        }
+        for scene in scenes {
+            if let window = scene.windows.first(where: { $0.isKeyWindow }) { return window }
+        }
+        return scenes.first?.windows.first
+    }
+
+    /// Bounds of the main screen (or `.zero` when no scene is connected).
+    public static func screenBounds() -> CGRect {
+        if let window = keyWindow() {
+            return window.windowScene?.screen.bounds ?? window.bounds
+        }
+        let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+        return scenes.first?.screen.bounds ?? .zero
+    }
+
+    /// The display scale of the main screen.
+    public static func screenScale() -> CGFloat {
+        let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+        return scenes.first?.screen.scale ?? 2.0
+    }
+
+    /// The topmost view controller suitable for presenting alerts and sheets.
+    public static func topViewController() -> UIViewController? {
+        guard var top = keyWindow()?.rootViewController else { return nil }
+        if let nav = top as? UINavigationController, let visible = nav.visibleViewController {
+            top = visible
+        } else if let tabs = top as? UITabBarController, let selected = tabs.selectedViewController {
+            top = selected
+        }
+        while let presented = top.presentedViewController {
+            top = presented
+        }
+        return top
+    }
+
+    /// Current system appearance as `"light"` or `"dark"`.
+    public static func colorScheme(for view: UIView? = nil) -> String {
+        let traits = view?.traitCollection ?? keyWindow()?.traitCollection ?? UITraitCollection.current
+        return traits.userInterfaceStyle == .dark ? "dark" : "light"
+    }
+}

pythonnative/native/ios/Tests/PythonNativeKitTests/PNAnimationGraphTests.swift

@@ -0,0 +1,26 @@
+import XCTest
+@testable import PythonNativeKit
+
+final class PNAnimationGraphTests: XCTestCase {
+    override func tearDown() {
+        PNAnimationGraph.forget(9401)
+        super.tearDown()
+    }
+
+    func testDerivedGraphReplacementKeepsDriverAndReleasesItOnUnmount() {
+        let nodes: [[String: Any]] = [
+            ["id": 101, "kind": "value", "value": 0.0],
+            ["id": 102, "kind": "multiply", "inputs": [["node": 101], ["constant": 2.0]]],
+        ]
+        PNAnimationGraph.install(["id": 101, "nodes": nodes, "bindings": [[9401, "opacity", 102]]])
+        PNAnimationGraph.set(101, 0.25)
+        XCTAssertEqual(PNAnimationGraph.values[102], 0.5)
+        XCTAssertTrue(PNAnimationGraph.start(9501, node: 101, spec: ["kind": "timing", "to": 1.0]))
+        PNAnimationGraph.install(["id": 100, "nodes": nodes, "bindings": [[9401, "opacity", 102]]])
+        XCTAssertNotNil(PNAnimationGraph.drivers[9501])
+        XCTAssertEqual(PNAnimationGraph.values[101], 0.25)
+        PNAnimationGraph.forget(9401)
+        XCTAssertNil(PNAnimationGraph.drivers[9501])
+        XCTAssertNil(PNAnimationGraph.values[101])
+    }
+}

pythonnative/native/ios/Tests/PythonNativeKitTests/PNColorTests.swift

@@ -0,0 +1,50 @@
+import XCTest
+@testable import PythonNativeKit
+
+final class PNColorTests: XCTestCase {
+    private func rgba(_ color: UIColor?) -> [Int] {
+        guard let color = color else { return [] }
+        let c = PNColor.components(color)
+        return [c.r, c.g, c.b, c.a].map { Int(round($0 * 255)) }
+    }
+
+    func testHexForms() {
+        XCTAssertEqual(rgba(PNColor.parse("#f00")), [255, 0, 0, 255])
+        XCTAssertEqual(rgba(PNColor.parse("#00ff00")), [0, 255, 0, 255])
+        XCTAssertEqual(rgba(PNColor.parse("#800000ff")), [0, 0, 255, 128])
+        XCTAssertEqual(rgba(PNColor.parse("#0000FF")), [0, 0, 255, 255])
+    }
+
+    func testFunctionalForms() {
+        XCTAssertEqual(rgba(PNColor.parse("rgb(10, 20, 30)")), [10, 20, 30, 255])
+        XCTAssertEqual(rgba(PNColor.parse("rgba(10, 20, 30, 0.5)")), [10, 20, 30, 128])
+    }
+
+    func testNamedColorsAndTransparent() {
+        XCTAssertEqual(rgba(PNColor.parse("red")), [255, 0, 0, 255])
+        XCTAssertEqual(rgba(PNColor.parse("white")), [255, 255, 255, 255])
+        XCTAssertEqual(rgba(PNColor.parse("transparent")), [0, 0, 0, 0])
+        XCTAssertNil(PNColor.parse(nil))
+        XCTAssertNil(PNColor.parse(""))
+        XCTAssertNil(PNColor.parse("not-a-color"))
+    }
+
+    func testIntegerARGB() {
+        XCTAssertEqual(rgba(PNColor.parse(0xFF112233 as Int64)), [0x11, 0x22, 0x33, 255])
+    }
+
+    func testDynamicLightDark() {
+        let color = PNColor.parse(["light": "#ffffff", "dark": "#000000"])
+        XCTAssertNotNil(color)
+        let light = color?.resolvedColor(with: UITraitCollection(userInterfaceStyle: .light))
+        let dark = color?.resolvedColor(with: UITraitCollection(userInterfaceStyle: .dark))
+        XCTAssertEqual(rgba(light), [255, 255, 255, 255])
+        XCTAssertEqual(rgba(dark), [0, 0, 0, 255])
+    }
+
+    func testHexRoundTrip() {
+        let hex = PNColor.hexString(UIColor(red: 1, green: 0, blue: 0, alpha: 1))
+        XCTAssertEqual(hex.lowercased(), "#ffff0000", "ARGB, matching the Python animated color format")
+        XCTAssertEqual(rgba(PNColor.parse(hex)), [255, 0, 0, 255])
+    }
+}