pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/ios/Sources/PythonNativeKit/Modules/PermissionModules.swift

@@ -0,0 +1,266 @@
+import AVFoundation
+import Contacts
+import CoreLocation
+import LocalAuthentication
+import Photos
+import UIKit
+import UserNotifications
+
+/// `Permissions`: `check` (sync) and `request` (async).
+///
+/// Permission names are the `[permissions]` keys from pythonnative.toml
+/// (`camera`, `microphone`, `photo_library`, `location_when_in_use`,
+/// `contacts`, `notifications`). The Python facade validates them before
+/// the call reaches this module, so an unknown name here is a bug rather
+/// than user input, and is rejected rather than answered.
+public final class PermissionsModule: PNNativeModule {
+    public static let name = "Permissions"
+
+    /// Every accepted permission name, in the `[permissions]` vocabulary.
+    public static let names: Set<String> = [
+        "camera", "microphone", "photo_library", "location_when_in_use", "contacts", "notifications",
+    ]
+
+    private var locationRequester: PNLocationPermissionRequester?
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        let permission = PNProps.string(args["permission"]) ?? ""
+        switch method {
+        case "check", "request":
+            guard PermissionsModule.names.contains(permission) else {
+                return promise.reject("unknown permission '\(permission)'", code: "bad_args")
+            }
+            if method == "check" {
+                check(permission) { promise.resolve($0) }
+            } else {
+                request(permission) { promise.resolve($0) }
+            }
+        default:
+            promise.reject("Permissions has no method '\(method)'", code: "unknown_method")
+        }
+    }
+
+    // MARK: - Check
+
+    private func check(_ permission: String, _ done: @escaping (String) -> Void) {
+        switch permission {
+        case "camera":
+            done(PermissionsModule.status(AVCaptureDevice.authorizationStatus(for: .video)))
+        case "microphone":
+            done(PermissionsModule.status(AVCaptureDevice.authorizationStatus(for: .audio)))
+        case "photo_library":
+            done(PermissionsModule.status(PHPhotoLibrary.pnReadWriteAuthorizationStatus()))
+        case "contacts":
+            done(PermissionsModule.status(CNContactStore.authorizationStatus(for: .contacts)))
+        case "location_when_in_use":
+            done(PermissionsModule.status(CLLocationManager().pnAuthorizationStatus))
+        case "notifications":
+            UNUserNotificationCenter.current().getNotificationSettings { settings in
+                let status: String
+                switch settings.authorizationStatus {
+                case .authorized, .provisional, .ephemeral: status = "granted"
+                case .denied: status = "blocked"
+                case .notDetermined: status = "undetermined"
+                @unknown default: status = "undetermined"
+                }
+                DispatchQueue.main.async { done(status) }
+            }
+        default:
+            done("undetermined")
+        }
+    }
+
+    // MARK: - Request
+
+    private func request(_ permission: String, _ done: @escaping (String) -> Void) {
+        let finish: (String) -> Void = { status in DispatchQueue.main.async { done(status) } }
+        switch permission {
+        case "camera":
+            AVCaptureDevice.requestAccess(for: .video) { finish($0 ? "granted" : "blocked") }
+        case "microphone":
+            AVCaptureDevice.requestAccess(for: .audio) { finish($0 ? "granted" : "blocked") }
+        case "photo_library":
+            PHPhotoLibrary.pnRequestReadWriteAuthorization { finish(PermissionsModule.status($0)) }
+        case "contacts":
+            CNContactStore().requestAccess(for: .contacts) { granted, _ in finish(granted ? "granted" : "blocked") }
+        case "notifications":
+            UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { granted, _ in
+                finish(granted ? "granted" : "blocked")
+            }
+        case "location_when_in_use":
+            let requester = PNLocationPermissionRequester { [weak self] status in
+                self?.locationRequester = nil
+                finish(status)
+            }
+            locationRequester = requester
+            requester.start()
+        default:
+            done("undetermined")
+        }
+    }
+
+    // MARK: - Status mapping
+
+    static func status(_ s: AVAuthorizationStatus) -> String {
+        switch s {
+        case .authorized: return "granted"
+        case .denied: return "blocked"
+        case .restricted: return "blocked"
+        case .notDetermined: return "undetermined"
+        @unknown default: return "undetermined"
+        }
+    }
+
+    static func status(_ s: PHAuthorizationStatus) -> String {
+        switch s {
+        case .authorized, .limited: return "granted"
+        case .denied, .restricted: return "blocked"
+        case .notDetermined: return "undetermined"
+        @unknown default: return "undetermined"
+        }
+    }
+
+    static func status(_ s: CNAuthorizationStatus) -> String {
+        switch s {
+        case .authorized: return "granted"
+        case .denied, .restricted: return "blocked"
+        case .notDetermined: return "undetermined"
+        // `.limited` (iOS 18) and future cases still permit access.
+        default: return "granted"
+        }
+    }
+
+    static func status(_ s: CLAuthorizationStatus) -> String {
+        switch s {
+        case .authorizedAlways, .authorizedWhenInUse: return "granted"
+        case .denied, .restricted: return "blocked"
+        case .notDetermined: return "undetermined"
+        @unknown default: return "undetermined"
+        }
+    }
+}
+
+/// One-shot when-in-use authorization request.
+final class PNLocationPermissionRequester: NSObject, CLLocationManagerDelegate {
+    private let manager = CLLocationManager()
+    private let done: (String) -> Void
+    private var finished = false
+
+    init(done: @escaping (String) -> Void) {
+        self.done = done
+        super.init()
+        manager.delegate = self
+    }
+
+    func start() {
+        let current = manager.pnAuthorizationStatus
+        if current != .notDetermined {
+            finish(PermissionsModule.status(current))
+            return
+        }
+        manager.requestWhenInUseAuthorization()
+    }
+
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        let status = manager.pnAuthorizationStatus
+        if status != .notDetermined {
+            finish(PermissionsModule.status(status))
+        }
+    }
+
+    private func finish(_ status: String) {
+        if finished { return }
+        finished = true
+        done(status)
+    }
+}
+
+/// `Notifications`: local notifications plus APNs registration.
+public final class NotificationsModule: PNNativeModule {
+    public static let name = "Notifications"
+
+    private static var tokenWaiters: [PNPromise] = []
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        let center = UNUserNotificationCenter.current()
+        switch method {
+        case "request_permission":
+            center.requestAuthorization(options: [.alert, .badge, .sound]) { granted, _ in
+                DispatchQueue.main.async { promise.resolve(granted) }
+            }
+        case "schedule":
+            let content = UNMutableNotificationContent()
+            content.title = PNProps.string(args["title"]) ?? ""
+            content.body = PNProps.string(args["body"]) ?? ""
+            if PNProps.bool(args["sound"]) != false { content.sound = .default }
+            if let badge = PNProps.int(args["badge"]) { content.badge = NSNumber(value: badge) }
+            let delay = max(0.1, PNProps.double(args["delay_seconds"]) ?? 0)
+            let trigger = UNTimeIntervalNotificationTrigger(timeInterval: delay, repeats: false)
+            let identifier = PNProps.string(args["identifier"]) ?? "default"
+            center.add(UNNotificationRequest(identifier: identifier, content: content, trigger: trigger)) { error in
+                DispatchQueue.main.async {
+                    if let error = error {
+                        PNLog.modules.error("schedule failed: \(error.localizedDescription)")
+                    }
+                    promise.resolve(error == nil)
+                }
+            }
+        case "cancel":
+            let identifier = PNProps.string(args["identifier"]) ?? "default"
+            center.removePendingNotificationRequests(withIdentifiers: [identifier])
+            center.removeDeliveredNotifications(withIdentifiers: [identifier])
+            promise.resolve(nil)
+        case "get_device_token":
+            NotificationsModule.tokenWaiters.append(promise)
+            UIApplication.shared.registerForRemoteNotifications()
+        default:
+            promise.reject("Notifications has no method '\(method)'", code: "unknown_method")
+        }
+    }
+
+    /// Called by the app delegate with the APNs token.
+    public static func deliverToken(_ token: Data) {
+        let hex = token.map { String(format: "%02x", $0) }.joined()
+        let waiters = tokenWaiters
+        tokenWaiters = []
+        for waiter in waiters { waiter.resolve(hex) }
+    }
+
+    /// Called by the app delegate when APNs registration fails.
+    public static func deliverError(_ error: Error) {
+        let waiters = tokenWaiters
+        tokenWaiters = []
+        for waiter in waiters { waiter.reject(String(describing: error), code: "apns") }
+    }
+}
+
+/// `Biometrics`: `LAContext` availability and authentication.
+public final class BiometricsModule: PNNativeModule {
+    public static let name = "Biometrics"
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "is_available":
+            let context = LAContext()
+            var error: NSError?
+            promise.resolve(context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error))
+        case "authenticate":
+            let context = LAContext()
+            let reason = PNProps.string(args["reason"]) ?? "Authenticate"
+            var error: NSError?
+            let policy: LAPolicy = context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error)
+                ? .deviceOwnerAuthenticationWithBiometrics : .deviceOwnerAuthentication
+            context.evaluatePolicy(policy, localizedReason: reason) { success, _ in
+                DispatchQueue.main.async { promise.resolve(success) }
+            }
+        default:
+            promise.reject("Biometrics has no method '\(method)'", code: "unknown_method")
+        }
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Modules/SystemModules.swift

@@ -0,0 +1,251 @@
+import AudioToolbox
+import Security
+import UIKit
+
+/// `Device`: static device and app-path information.
+public final class DeviceModule: PNNativeModule {
+    public static let name = "Device"
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "info":
+            promise.resolve(DeviceModule.info())
+        default:
+            promise.reject("Device has no method '\(method)'", code: "unknown_method")
+        }
+    }
+
+    /// The `Device.info()` payload.
+    public static func info() -> [String: Any] {
+        let paths = FileManager.default
+        let documents = paths.urls(for: .documentDirectory, in: .userDomainMask).first?.path ?? NSHomeDirectory() + "/Documents"
+        let caches = paths.urls(for: .cachesDirectory, in: .userDomainMask).first?.path ?? NSTemporaryDirectory()
+        return [
+            "os": "ios",
+            "os_version": UIDevice.current.systemVersion,
+            "model": UIDevice.current.model,
+            "name": UIDevice.current.name,
+            "app_dir": documents,
+            "cache_dir": caches,
+            "locale": Locale.current.identifier,
+            "scale": Double(PNWindow.screenScale()),
+            "is_simulator": DeviceModule.isSimulator,
+        ]
+    }
+
+    static var isSimulator: Bool {
+        #if targetEnvironment(simulator)
+        return true
+        #else
+        return false
+        #endif
+    }
+}
+
+/// `Storage`: `AsyncStorage` over the `pn_async_storage` defaults suite.
+public final class StorageModule: PNNativeModule {
+    public static let name = "Storage"
+    static let suiteName = "pn_async_storage"
+
+    private let defaults: UserDefaults
+
+    public init() {
+        defaults = UserDefaults(suiteName: StorageModule.suiteName) ?? .standard
+    }
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "get":
+            guard let key = PNProps.string(args["key"]) else { return promise.reject("missing key", code: "bad_args") }
+            promise.resolve(defaults.string(forKey: key))
+        case "set":
+            guard let key = PNProps.string(args["key"]) else { return promise.reject("missing key", code: "bad_args") }
+            defaults.set(PNProps.string(args["value"]) ?? "", forKey: key)
+            promise.resolve(nil)
+        case "delete":
+            guard let key = PNProps.string(args["key"]) else { return promise.reject("missing key", code: "bad_args") }
+            defaults.removeObject(forKey: key)
+            promise.resolve(nil)
+        case "all_keys":
+            let keys: [String] = defaults.persistentDomain(forName: StorageModule.suiteName)?.keys.map { $0 } ?? []
+            promise.resolve(keys.sorted())
+        case "clear":
+            defaults.removePersistentDomain(forName: StorageModule.suiteName)
+            promise.resolve(nil)
+        default:
+            promise.reject("Storage has no method '\(method)'", code: "unknown_method")
+        }
+    }
+}
+
+/// `SecureStore`: Keychain generic passwords under one service.
+public final class SecureStoreModule: PNNativeModule {
+    public static let name = "SecureStore"
+    static let service = "com.pythonnative.securestore"
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        guard let key = PNProps.string(args["key"]) else {
+            promise.reject("missing key", code: "bad_args")
+            return
+        }
+        switch method {
+        case "set_item":
+            promise.resolve(SecureStoreModule.set(key, PNProps.string(args["value"]) ?? ""))
+        case "get_item":
+            promise.resolve(SecureStoreModule.get(key))
+        case "delete_item":
+            promise.resolve(SecureStoreModule.delete(key))
+        default:
+            promise.reject("SecureStore has no method '\(method)'", code: "unknown_method")
+        }
+    }
+
+    private static func query(_ key: String) -> [String: Any] {
+        [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key,
+        ]
+    }
+
+    static func set(_ key: String, _ value: String) -> Bool {
+        let data = Data(value.utf8)
+        var q = query(key)
+        let status = SecItemCopyMatching(q as CFDictionary, nil)
+        if status == errSecSuccess {
+            return SecItemUpdate(q as CFDictionary, [kSecValueData as String: data] as CFDictionary) == errSecSuccess
+        }
+        q[kSecValueData as String] = data
+        q[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlock
+        return SecItemAdd(q as CFDictionary, nil) == errSecSuccess
+    }
+
+    static func get(_ key: String) -> String? {
+        var q = query(key)
+        q[kSecReturnData as String] = true
+        q[kSecMatchLimit as String] = kSecMatchLimitOne
+        var result: CFTypeRef?
+        guard SecItemCopyMatching(q as CFDictionary, &result) == errSecSuccess, let data = result as? Data else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    static func delete(_ key: String) -> Bool {
+        SecItemDelete(query(key) as CFDictionary) == errSecSuccess
+    }
+}
+
+/// `Clipboard`: the general pasteboard.
+public final class ClipboardModule: PNNativeModule {
+    public static let name = "Clipboard"
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "set_string":
+            UIPasteboard.general.string = PNProps.string(args["text"]) ?? ""
+            promise.resolve(nil)
+        case "get_string":
+            promise.resolve(UIPasteboard.general.string ?? "")
+        default:
+            promise.reject("Clipboard has no method '\(method)'", code: "unknown_method")
+        }
+    }
+}
+
+/// `Share`: `UIActivityViewController`, resolving whether a share completed.
+public final class ShareModule: PNNativeModule {
+    public static let name = "Share"
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        guard method == "share" else {
+            promise.reject("Share has no method '\(method)'", code: "unknown_method")
+            return
+        }
+        var items: [Any] = []
+        if let message = PNProps.string(args["message"]), !message.isEmpty { items.append(message) }
+        if let url = PNProps.string(args["url"]).flatMap({ URL(string: $0) }) { items.append(url) }
+        guard !items.isEmpty, let top = PNWindow.topViewController() else {
+            promise.resolve(false)
+            return
+        }
+        let controller = UIActivityViewController(activityItems: items, applicationActivities: nil)
+        if let title = PNProps.string(args["title"]) {
+            controller.setValue(title, forKey: "subject")
+        }
+        controller.completionWithItemsHandler = { _, completed, _, _ in
+            promise.resolve(completed)
+        }
+        if let popover = controller.popoverPresentationController {
+            popover.sourceView = top.view
+            popover.sourceRect = CGRect(x: top.view.bounds.midX, y: top.view.bounds.midY, width: 1, height: 1)
+            popover.permittedArrowDirections = []
+        }
+        top.present(controller, animated: true)
+    }
+}
+
+/// `Haptics`: feedback generators plus the legacy vibration sound.
+public final class HapticsModule: PNNativeModule {
+    public static let name = "Haptics"
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "impact":
+            let generator = UIImpactFeedbackGenerator(style: HapticsModule.impactStyle(PNProps.string(args["style"])))
+            generator.prepare()
+            generator.impactOccurred()
+            promise.resolve(nil)
+        case "notification":
+            let generator = UINotificationFeedbackGenerator()
+            generator.prepare()
+            generator.notificationOccurred(HapticsModule.notificationType(PNProps.string(args["type"])))
+            promise.resolve(nil)
+        case "selection":
+            let generator = UISelectionFeedbackGenerator()
+            generator.prepare()
+            generator.selectionChanged()
+            promise.resolve(nil)
+        case "vibrate":
+            let duration = PNProps.int(args["duration_ms"]) ?? 400
+            if duration <= 100 {
+                let generator = UIImpactFeedbackGenerator(style: .heavy)
+                generator.prepare()
+                generator.impactOccurred()
+            } else {
+                AudioServicesPlaySystemSound(kSystemSoundID_Vibrate)
+            }
+            promise.resolve(nil)
+        case "cancel":
+            promise.resolve(nil)
+        default:
+            promise.reject("Haptics has no method '\(method)'", code: "unknown_method")
+        }
+    }
+
+    static func impactStyle(_ name: String?) -> UIImpactFeedbackGenerator.FeedbackStyle {
+        switch name {
+        case "light": return .light
+        case "heavy": return .heavy
+        case "soft": return .soft
+        case "rigid": return .rigid
+        default: return .medium
+        }
+    }
+
+    static func notificationType(_ name: String?) -> UINotificationFeedbackGenerator.FeedbackType {
+        switch name {
+        case "warning": return .warning
+        case "error": return .error
+        default: return .success
+        }
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Plugins/PNPluginRegistration.swift

@@ -0,0 +1,8 @@
+// Generated by `pn build`. Do not edit: the PythonNative build tool
+// overwrites this file with one `register(into:)` call per bundled plugin.
+
+/// Registration hook for plugins copied into `Sources/Plugins` by `pn build`.
+public enum PNGeneratedPlugins {
+    /// Register every generated plugin into `registry`.
+    public static func registerAll(into registry: PNRegistry) {}
+}

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

@@ -0,0 +1,46 @@
+import UIKit
+
+/// Screen id <-> `PNViewController` table.
+///
+/// Python addresses screens by the integer id assigned here; the
+/// controller is held weakly so a popped screen is reclaimed normally.
+public final class PNScreenRegistry {
+    public static let shared = PNScreenRegistry()
+
+    private final class WeakBox {
+        weak var controller: PNViewController?
+        init(_ controller: PNViewController) { self.controller = controller }
+    }
+
+    private var screens: [Int64: WeakBox] = [:]
+    private var nextId: Int64 = 1
+
+    private init() {}
+
+    /// Assign a fresh id to `controller`.
+    func register(_ controller: PNViewController) -> Int64 {
+        let id = nextId
+        nextId += 1
+        screens[id] = WeakBox(controller)
+        return id
+    }
+
+    /// Forget `id` (called from the controller's deinit).
+    func unregister(_ id: Int64) {
+        screens.removeValue(forKey: id)
+    }
+
+    /// The controller for `id`, if it's still alive.
+    public func controller(for id: Int64) -> PNViewController? {
+        guard let box = screens[id] else { return nil }
+        if box.controller == nil {
+            screens.removeValue(forKey: id)
+        }
+        return box.controller
+    }
+
+    /// Ids of every live screen.
+    public var screenIds: [Int64] {
+        screens.compactMap { $0.value.controller == nil ? nil : $0.key }.sorted()
+    }
+}