pyxpo-device 0.1.0a1__tar.gz

pyxpo_device-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vishal Chaubey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyxpo_device-0.1.0a1/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: pyxpo-device
+Version: 0.1.0a1
+Summary: Device facts for pyxpo apps: brand, model, OS, memory, device type (expo-device shape).
+Author: Vishal Chaubey
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pyxpo/pyxpo/tree/main/packages/device
+Project-URL: Issues, https://github.com/pyxpo/pyxpo/issues
+Keywords: pyxpo,pyxpo-module,mobile,android,ios
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyxpo<0.2,>=0.1.0a2
+Dynamic: license-file
+
+# pyxpo-device
+
+Facts about the device a [pyxpo](https://github.com/pyxpo/pyxpo) app runs on: brand, model, OS, memory and
+device type. The API follows [expo-device](https://docs.expo.dev/versions/latest/sdk/device/).
+
+```sh
+pip install pyxpo-device
+```
+
+```toml
+[tool.pyxpo]
+modules = ["device"]
+```
+
+```python
+import pyxpo_device as Device
+
+print(Device.brand, Device.model_name, Device.os_name, Device.os_version)
+if Device.device_type == Device.DeviceType.TABLET:
+    ...
+uptime_ms = await Device.get_uptime_async()
+```
+
+Every name also has its expo-device spelling (`Device.modelName`, `Device.getUptimeAsync`).
+
+## Constants
+
+Read once at app start, no bridge round trip. `None` where a platform has no value.
+
+| Name | iOS | Android |
+| --- | --- | --- |
+| `is_device` | False on the Simulator | False on an emulator (best-effort check) |
+| `brand`, `manufacturer` | `"Apple"` | `Build.BRAND`, `Build.MANUFACTURER` |
+| `model_name` | Marketing name for known iPhones, else the identifier | `Build.MODEL` |
+| `model_id` | Identifier, for example `"iPhone17,3"` | None |
+| `design_name`, `product_name` | None | `Build.DEVICE`, `Build.PRODUCT` |
+| `device_year_class` | Release year of known iPhones | None |
+| `total_memory` | Bytes of RAM | Bytes of RAM |
+| `supported_cpu_architectures` | `["arm64"]` | `Build.SUPPORTED_ABIS` |
+| `os_name` | `"iOS"` or `"iPadOS"` | `"Android"` |
+| `os_version` | For example `"26.0"` | For example `"15"` |
+| `os_build_id`, `os_internal_build_id` | Kernel OS build | `Build.DISPLAY`, `Build.ID` |
+| `os_build_fingerprint`, `platform_api_level` | None | `Build.FINGERPRINT`, API level |
+| `device_name` | `UIDevice.name` (a generic name on iOS 16+) | Device name setting, else the model |
+| `device_type` | `DeviceType` from the interface idiom | `DeviceType` from TV mode and screen width (600dp+ = tablet) |
+
+On the desktop the values come from Python's `platform` module and `device_type` is `DESKTOP`.
+
+## Functions
+
+- `get_device_type_async()` -> `DeviceType`
+- `get_uptime_async()` -> milliseconds since boot, not counting deep sleep
+- `get_max_memory_async()` -> Android: the runtime's memory limit in bytes; elsewhere `MAX_SAFE_INTEGER`
+- `is_rooted_experimental_async()` -> best-effort jailbreak or root check. Easy to fool; never use it for security.
+- `is_side_loading_enabled_async()` -> Android: whether the app may install apps (needs `REQUEST_INSTALL_PACKAGES` on Android 8+)
+- `get_platform_features_async()` -> Android system feature names; `[]` elsewhere
+- `has_platform_feature_async(feature)` -> Android: for example `"android.hardware.camera"`; `False` elsewhere
+
+## Permissions
+
+None.

pyxpo_device-0.1.0a1/README.md

@@ -0,0 +1,61 @@
+# pyxpo-device
+
+Facts about the device a [pyxpo](https://github.com/pyxpo/pyxpo) app runs on: brand, model, OS, memory and
+device type. The API follows [expo-device](https://docs.expo.dev/versions/latest/sdk/device/).
+
+```sh
+pip install pyxpo-device
+```
+
+```toml
+[tool.pyxpo]
+modules = ["device"]
+```
+
+```python
+import pyxpo_device as Device
+
+print(Device.brand, Device.model_name, Device.os_name, Device.os_version)
+if Device.device_type == Device.DeviceType.TABLET:
+    ...
+uptime_ms = await Device.get_uptime_async()
+```
+
+Every name also has its expo-device spelling (`Device.modelName`, `Device.getUptimeAsync`).
+
+## Constants
+
+Read once at app start, no bridge round trip. `None` where a platform has no value.
+
+| Name | iOS | Android |
+| --- | --- | --- |
+| `is_device` | False on the Simulator | False on an emulator (best-effort check) |
+| `brand`, `manufacturer` | `"Apple"` | `Build.BRAND`, `Build.MANUFACTURER` |
+| `model_name` | Marketing name for known iPhones, else the identifier | `Build.MODEL` |
+| `model_id` | Identifier, for example `"iPhone17,3"` | None |
+| `design_name`, `product_name` | None | `Build.DEVICE`, `Build.PRODUCT` |
+| `device_year_class` | Release year of known iPhones | None |
+| `total_memory` | Bytes of RAM | Bytes of RAM |
+| `supported_cpu_architectures` | `["arm64"]` | `Build.SUPPORTED_ABIS` |
+| `os_name` | `"iOS"` or `"iPadOS"` | `"Android"` |
+| `os_version` | For example `"26.0"` | For example `"15"` |
+| `os_build_id`, `os_internal_build_id` | Kernel OS build | `Build.DISPLAY`, `Build.ID` |
+| `os_build_fingerprint`, `platform_api_level` | None | `Build.FINGERPRINT`, API level |
+| `device_name` | `UIDevice.name` (a generic name on iOS 16+) | Device name setting, else the model |
+| `device_type` | `DeviceType` from the interface idiom | `DeviceType` from TV mode and screen width (600dp+ = tablet) |
+
+On the desktop the values come from Python's `platform` module and `device_type` is `DESKTOP`.
+
+## Functions
+
+- `get_device_type_async()` -> `DeviceType`
+- `get_uptime_async()` -> milliseconds since boot, not counting deep sleep
+- `get_max_memory_async()` -> Android: the runtime's memory limit in bytes; elsewhere `MAX_SAFE_INTEGER`
+- `is_rooted_experimental_async()` -> best-effort jailbreak or root check. Easy to fool; never use it for security.
+- `is_side_loading_enabled_async()` -> Android: whether the app may install apps (needs `REQUEST_INSTALL_PACKAGES` on Android 8+)
+- `get_platform_features_async()` -> Android system feature names; `[]` elsewhere
+- `has_platform_feature_async(feature)` -> Android: for example `"android.hardware.camera"`; `False` elsewhere
+
+## Permissions
+
+None.

pyxpo_device-0.1.0a1/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyxpo-device"
+dynamic = ["version"]
+description = "Device facts for pyxpo apps: brand, model, OS, memory, device type (expo-device shape)."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Vishal Chaubey" }]
+keywords = ["pyxpo", "pyxpo-module", "mobile", "android", "ios"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: User Interfaces",
+]
+requires-python = ">=3.9"
+dependencies = ["pyxpo>=0.1.0a2,<0.2"]
+
+[project.urls]
+Homepage = "https://github.com/pyxpo/pyxpo/tree/main/packages/device"
+Issues = "https://github.com/pyxpo/pyxpo/issues"
+
+# How `pyxpo build` finds this module: the entry point name is the module name apps list in
+# `[tool.pyxpo] modules`, its value the import package holding pyxpo-module.json.
+[project.entry-points."pyxpo.modules"]
+device = "pyxpo_device"
+
+[tool.setuptools]
+packages = ["pyxpo_device"]
+
+[tool.setuptools.dynamic]
+version = { attr = "pyxpo_device.__version__" }
+
+[tool.setuptools.package-data]
+pyxpo_device = ["pyxpo-module.json", "py.typed", "ios/**/*", "android/**/*"]
+
+[tool.setuptools.exclude-package-data]
+"*" = ["__pycache__", "*.pyc", ".DS_Store"]

pyxpo_device-0.1.0a1/pyxpo_device/__init__.py

@@ -0,0 +1,163 @@
+"""Facts about the device the app runs on: the expo-device API.
+
+    import pyxpo_device as Device
+
+    Device.brand, Device.model_name, Device.os_name, Device.os_version   # or Device.modelName, Device.osName ...
+    if Device.device_type == Device.DeviceType.TABLET: ...
+    ms = await Device.get_uptime_async()
+
+The constants are read once at startup (no bridge round trip). Values a platform does not have are None:
+`model_id` is iOS only; `design_name`, `product_name`, `os_build_fingerprint` and `platform_api_level` are
+Android only. `device_year_class` is the release year of the iPhone model (None for unknown models and on
+Android). On the desktop the values come from Python's `platform` module.
+"""
+from __future__ import annotations
+
+import os
+import platform as _py_platform
+import sys
+import time
+from enum import IntEnum
+from typing import Any, Dict, List, Optional
+
+from pyxpo.module_api import call, constants, platform, require_linked
+
+__version__ = "0.1.0a1"
+
+# Number.MAX_SAFE_INTEGER: what expo-device returns when memory has no inherent limit.
+MAX_SAFE_INTEGER = 2 ** 53 - 1
+
+
+class DeviceType(IntEnum):
+    """Kind of device, from the screen size and the platform's own idiom."""
+    UNKNOWN = 0
+    PHONE = 1
+    TABLET = 2
+    DESKTOP = 3
+    TV = 4
+
+
+_FIELDS = {
+    "isDevice": "is_device", "brand": "brand", "manufacturer": "manufacturer", "modelName": "model_name",
+    "modelId": "model_id", "designName": "design_name", "productName": "product_name",
+    "deviceYearClass": "device_year_class", "totalMemory": "total_memory",
+    "supportedCpuArchitectures": "supported_cpu_architectures", "osName": "os_name", "osVersion": "os_version",
+    "osBuildId": "os_build_id", "osInternalBuildId": "os_internal_build_id",
+    "osBuildFingerprint": "os_build_fingerprint", "platformApiLevel": "platform_api_level",
+    "deviceName": "device_name", "deviceType": "device_type",
+}
+_BY_SNAKE = {snake: camel for camel, snake in _FIELDS.items()}
+
+
+def _native() -> bool:
+    if platform() == "desktop":
+        return False
+    require_linked("Device", "device", package="pyxpo-device")
+    return True
+
+
+def _desktop() -> Dict[str, Any]:
+    u = _py_platform.uname()
+    total: Optional[int] = None
+    try:
+        total = os.sysconf("SC_PAGE_SIZE") * os.sysconf("SC_PHYS_PAGES")
+    except (AttributeError, ValueError, OSError):
+        pass
+    return {
+        "isDevice": True, "brand": None, "manufacturer": None, "modelName": None, "modelId": None,
+        "designName": None, "productName": None, "deviceYearClass": None, "totalMemory": total,
+        "supportedCpuArchitectures": [u.machine] if u.machine else None, "osName": u.system or sys.platform,
+        "osVersion": u.release or None, "osBuildId": u.version or None, "osInternalBuildId": u.version or None,
+        "osBuildFingerprint": None, "platformApiLevel": None, "deviceName": u.node or None,
+        "deviceType": int(DeviceType.DESKTOP),
+    }
+
+
+def _all() -> Dict[str, Any]:
+    if not _native():
+        return _desktop()
+    c = constants("Device")
+    return {k: c.get(k) for k in _FIELDS}
+
+
+def __getattr__(name: str) -> Any:
+    # Constants resolve on access: the startup env is not there yet when this module is imported.
+    camel = name if name in _FIELDS else _BY_SNAKE.get(name)
+    if camel is None:
+        raise AttributeError("module 'pyxpo_device' has no attribute %r" % name)
+    value = _all()[camel]
+    if camel == "deviceType":
+        return DeviceType(value) if value in DeviceType._value2member_map_ else DeviceType.UNKNOWN
+    if camel == "supportedCpuArchitectures" and value is not None:
+        return list(value)
+    return value
+
+
+async def get_device_type_async() -> DeviceType:
+    """The `DeviceType` of this device (same as `device_type`)."""
+    return __getattr__("deviceType")
+
+
+async def get_uptime_async() -> int:
+    """Milliseconds since the device booted, not counting deep sleep."""
+    if not _native():
+        return int(time.monotonic() * 1000)  # the system clock since boot on macOS and Linux
+    return int(await call("Device", "getUptime", reply=True))
+
+
+async def get_max_memory_async() -> int:
+    """Most memory (bytes) the Android runtime lets the app use. `MAX_SAFE_INTEGER` where there is no limit
+    (iOS, the desktop)."""
+    if platform() != "android" or not _native():
+        return MAX_SAFE_INTEGER
+    return int(await call("Device", "getMaxMemory", reply=True))
+
+
+async def is_rooted_experimental_async() -> bool:
+    """Best-effort jailbreak (iOS) or root (Android) check. Easy to fool: never use it for security."""
+    if not _native():
+        return False
+    return bool(await call("Device", "isRooted", reply=True))
+
+
+async def is_side_loading_enabled_async() -> bool:
+    """Android: whether this app may install other apps (needs REQUEST_INSTALL_PACKAGES on Android 8+).
+    Always False on iOS and the desktop."""
+    if platform() != "android" or not _native():
+        return False
+    return bool(await call("Device", "isSideLoadingEnabled", reply=True))
+
+
+async def get_platform_features_async() -> List[str]:
+    """Android: the system feature names the device reports (`PackageManager.getSystemAvailableFeatures`).
+    Empty on iOS and the desktop."""
+    if platform() != "android" or not _native():
+        return []
+    return list(await call("Device", "getPlatformFeatures", reply=True) or [])
+
+
+async def has_platform_feature_async(feature: str) -> bool:
+    """Android: whether the device has a system feature, for example "android.hardware.camera".
+    Always False on iOS and the desktop."""
+    if not isinstance(feature, str) or not feature:
+        raise ValueError("feature must be a non-empty string")
+    if platform() != "android" or not _native():
+        return False
+    return bool(await call("Device", "hasPlatformFeature", feature, reply=True))
+
+
+getDeviceTypeAsync = get_device_type_async
+getUptimeAsync = get_uptime_async
+getMaxMemoryAsync = get_max_memory_async
+isRootedExperimentalAsync = is_rooted_experimental_async
+isSideLoadingEnabledAsync = is_side_loading_enabled_async
+getPlatformFeaturesAsync = get_platform_features_async
+hasPlatformFeatureAsync = has_platform_feature_async
+
+__all__ = [
+    "DeviceType", "MAX_SAFE_INTEGER", "get_device_type_async", "get_uptime_async", "get_max_memory_async",
+    "is_rooted_experimental_async", "is_side_loading_enabled_async", "get_platform_features_async",
+    "has_platform_feature_async", "getDeviceTypeAsync", "getUptimeAsync", "getMaxMemoryAsync",
+    "isRootedExperimentalAsync", "isSideLoadingEnabledAsync", "getPlatformFeaturesAsync",
+    "hasPlatformFeatureAsync",
+] + list(_FIELDS) + list(_FIELDS.values())

pyxpo_device-0.1.0a1/pyxpo_device/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

pyxpo_device-0.1.0a1/pyxpo_device/android/src/main/java/dev/pyxpo/modules/device/DeviceModule.kt

@@ -0,0 +1,91 @@
+package dev.pyxpo.modules.device
+
+import android.app.ActivityManager
+import android.app.UiModeManager
+import android.content.Context
+import android.content.res.Configuration
+import android.os.Build
+import android.os.SystemClock
+import android.provider.Settings
+import dev.pyxpo.moduleapi.PxModule
+import dev.pyxpo.moduleapi.PxModuleContext
+import dev.pyxpo.moduleapi.PxReply
+import org.json.JSONArray
+import java.io.File
+
+/** expo-device on Android. Constants come from `Build`, `ActivityManager` and the configuration at startup. */
+class DeviceModule : PxModule() {
+    override val name = "Device"
+
+    override fun constants(context: Context): Map<String, Any?> {
+        val mem = ActivityManager.MemoryInfo()
+        (context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager).getMemoryInfo(mem)
+        return mapOf(
+            "isDevice" to !isEmulator(),
+            "brand" to Build.BRAND,
+            "manufacturer" to Build.MANUFACTURER,
+            "modelName" to Build.MODEL,
+            "modelId" to null,
+            "designName" to Build.DEVICE,
+            "productName" to Build.PRODUCT,
+            "deviceYearClass" to null,
+            "totalMemory" to mem.totalMem,
+            "supportedCpuArchitectures" to Build.SUPPORTED_ABIS.toList(),
+            "osName" to "Android",
+            "osVersion" to Build.VERSION.RELEASE,
+            "osBuildId" to Build.DISPLAY,
+            "osInternalBuildId" to Build.ID,
+            "osBuildFingerprint" to Build.FINGERPRINT,
+            "platformApiLevel" to Build.VERSION.SDK_INT,
+            "deviceName" to (Settings.Global.getString(context.contentResolver, Settings.Global.DEVICE_NAME) ?: Build.MODEL),
+            "deviceType" to deviceType(context),
+        )
+    }
+
+    private fun isEmulator(): Boolean =
+        Build.FINGERPRINT.startsWith("generic") || Build.FINGERPRINT.contains("emulator") ||
+            Build.HARDWARE == "goldfish" || Build.HARDWARE == "ranchu" ||
+            Build.MODEL.contains("Emulator") || Build.MODEL.contains("Android SDK built for") ||
+            Build.PRODUCT.startsWith("sdk") || Build.PRODUCT.contains("emulator") || Build.PRODUCT.contains("simulator")
+
+    private fun deviceType(context: Context): Int {
+        val ui = context.getSystemService(Context.UI_MODE_SERVICE) as? UiModeManager
+        if (ui?.currentModeType == Configuration.UI_MODE_TYPE_TELEVISION) return 4
+        val pm = context.packageManager
+        if (pm.hasSystemFeature("android.software.leanback")) return 4
+        if (pm.hasSystemFeature("org.chromium.arc") || pm.hasSystemFeature("org.chromium.arc.device_management")) return 3
+        return if (context.resources.configuration.smallestScreenWidthDp >= 600) 2 else 1
+    }
+
+    private fun isRooted(): Boolean {
+        if (Build.TAGS?.contains("test-keys") == true) return true
+        val paths = listOf("/system/app/Superuser.apk", "/sbin/su", "/system/bin/su", "/system/xbin/su",
+            "/data/local/xbin/su", "/data/local/bin/su", "/system/sd/xbin/su", "/system/bin/failsafe/su", "/data/local/su")
+        return paths.any { File(it).exists() }
+    }
+
+    // Android 8+ throws unless the app declares REQUEST_INSTALL_PACKAGES; without it the answer is false.
+    private fun sideLoading(c: Context): Boolean =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            try { c.packageManager.canRequestPackageInstalls() } catch (e: SecurityException) { false }
+        } else {
+            @Suppress("DEPRECATION")
+            Settings.Secure.getInt(c.contentResolver, Settings.Secure.INSTALL_NON_MARKET_APPS, 0) == 1
+        }
+
+    override fun call(ctx: PxModuleContext, method: String, args: JSONArray, reply: PxReply) {
+        val c = ctx.activity
+        when (method) {
+            "getUptime" -> reply(SystemClock.uptimeMillis(), null)
+            "getMaxMemory" -> {
+                val max = Runtime.getRuntime().maxMemory()
+                reply(if (max == Long.MAX_VALUE) 9007199254740991L else max, null)
+            }
+            "isRooted" -> reply(isRooted(), null)
+            "isSideLoadingEnabled" -> reply(sideLoading(c), null)
+            "getPlatformFeatures" -> reply(c.packageManager.systemAvailableFeatures.mapNotNull { it.name }, null)
+            "hasPlatformFeature" -> reply(c.packageManager.hasSystemFeature(args.optString(0)), null)
+            else -> reply(null, "Device has no method '$method'")
+        }
+    }
+}

pyxpo_device-0.1.0a1/pyxpo_device/ios/DeviceModule.swift

@@ -0,0 +1,120 @@
+import UIKit
+
+/// expo-device on iOS. Constants are read once at startup; the model name comes from a table of iPhone
+/// identifiers (unknown models, iPads and newer phones report the raw identifier, for example "iPad14,1").
+final class DeviceModule: PxModule {
+    static let moduleName = "Device"
+
+    required init() {}
+
+    /// iPhone identifier: (marketing name, release year).
+    private static let iPhones: [String: (String, Int)] = [
+        "iPhone10,1": ("iPhone 8", 2017), "iPhone10,4": ("iPhone 8", 2017),
+        "iPhone10,2": ("iPhone 8 Plus", 2017), "iPhone10,5": ("iPhone 8 Plus", 2017),
+        "iPhone10,3": ("iPhone X", 2017), "iPhone10,6": ("iPhone X", 2017),
+        "iPhone11,2": ("iPhone XS", 2018), "iPhone11,4": ("iPhone XS Max", 2018),
+        "iPhone11,6": ("iPhone XS Max", 2018), "iPhone11,8": ("iPhone XR", 2018),
+        "iPhone12,1": ("iPhone 11", 2019), "iPhone12,3": ("iPhone 11 Pro", 2019),
+        "iPhone12,5": ("iPhone 11 Pro Max", 2019), "iPhone12,8": ("iPhone SE (2nd generation)", 2020),
+        "iPhone13,1": ("iPhone 12 mini", 2020), "iPhone13,2": ("iPhone 12", 2020),
+        "iPhone13,3": ("iPhone 12 Pro", 2020), "iPhone13,4": ("iPhone 12 Pro Max", 2020),
+        "iPhone14,4": ("iPhone 13 mini", 2021), "iPhone14,5": ("iPhone 13", 2021),
+        "iPhone14,2": ("iPhone 13 Pro", 2021), "iPhone14,3": ("iPhone 13 Pro Max", 2021),
+        "iPhone14,6": ("iPhone SE (3rd generation)", 2022), "iPhone14,7": ("iPhone 14", 2022),
+        "iPhone14,8": ("iPhone 14 Plus", 2022), "iPhone15,2": ("iPhone 14 Pro", 2022),
+        "iPhone15,3": ("iPhone 14 Pro Max", 2022), "iPhone15,4": ("iPhone 15", 2023),
+        "iPhone15,5": ("iPhone 15 Plus", 2023), "iPhone16,1": ("iPhone 15 Pro", 2023),
+        "iPhone16,2": ("iPhone 15 Pro Max", 2023), "iPhone17,3": ("iPhone 16", 2024),
+        "iPhone17,4": ("iPhone 16 Plus", 2024), "iPhone17,1": ("iPhone 16 Pro", 2024),
+        "iPhone17,2": ("iPhone 16 Pro Max", 2024), "iPhone17,5": ("iPhone 16e", 2025),
+        "iPhone18,3": ("iPhone 17", 2025), "iPhone18,1": ("iPhone 17 Pro", 2025),
+        "iPhone18,2": ("iPhone 17 Pro Max", 2025), "iPhone18,4": ("iPhone Air", 2025),
+        "iPhone18,5": ("iPhone 17e", 2026), "iPhone19,2": ("iPhone 18 Pro", 2026),
+        "iPhone19,3": ("iPhone 18 Pro Max", 2026),
+    ]
+
+    private static func sysctlString(_ name: String) -> String? {
+        var size = 0
+        guard sysctlbyname(name, nil, &size, nil, 0) == 0, size > 0 else { return nil }
+        var buf = [CChar](repeating: 0, count: size)
+        guard sysctlbyname(name, &buf, &size, nil, 0) == 0 else { return nil }
+        return String(cString: buf)
+    }
+
+    private static var isSimulator: Bool {
+        #if targetEnvironment(simulator)
+        return true
+        #else
+        return false
+        #endif
+    }
+
+    private static var modelId: String? {
+        if isSimulator, let id = ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"] { return id }
+        return sysctlString("hw.machine")
+    }
+
+    private static var deviceType: Int {
+        if ProcessInfo.processInfo.isiOSAppOnMac || ProcessInfo.processInfo.isMacCatalystApp { return 3 }
+        switch UIDevice.current.userInterfaceIdiom {
+        case .phone: return 1
+        case .pad: return 2
+        case .mac: return 3
+        case .tv: return 4
+        default: return 0
+        }
+    }
+
+    static var constants: [String: Any] {
+        let d = UIDevice.current
+        let id = modelId
+        let known = id.flatMap { iPhones[$0] }
+        let build: Any = sysctlString("kern.osversion") ?? NSNull()
+        var arch = "arm64"
+        #if arch(x86_64)
+        arch = "x86_64"
+        #endif
+        return [
+            "isDevice": !isSimulator,
+            "brand": "Apple",
+            "manufacturer": "Apple",
+            "modelName": known?.0 ?? id ?? NSNull(),
+            "modelId": id ?? NSNull(),
+            "designName": NSNull(),
+            "productName": NSNull(),
+            "deviceYearClass": known?.1 ?? NSNull(),
+            "totalMemory": ProcessInfo.processInfo.physicalMemory,
+            "supportedCpuArchitectures": [arch],
+            "osName": d.userInterfaceIdiom == .pad ? "iPadOS" : d.systemName,
+            "osVersion": d.systemVersion,
+            "osBuildId": build,
+            "osInternalBuildId": build,
+            "osBuildFingerprint": NSNull(),
+            "platformApiLevel": NSNull(),
+            "deviceName": d.name,
+            "deviceType": deviceType,
+        ]
+    }
+
+    private static var looksJailbroken: Bool {
+        if isSimulator { return false }
+        let paths = ["/Applications/Cydia.app", "/Library/MobileSubstrate/MobileSubstrate.dylib", "/bin/bash",
+                     "/usr/sbin/sshd", "/etc/apt", "/private/var/lib/apt/", "/var/jb"]
+        if paths.contains(where: { FileManager.default.fileExists(atPath: $0) }) { return true }
+        // A sandboxed app cannot write outside its container.
+        let probe = "/private/pyxpo-jb-probe.txt"
+        if (try? "x".write(toFile: probe, atomically: true, encoding: .utf8)) != nil {
+            try? FileManager.default.removeItem(atPath: probe)
+            return true
+        }
+        return false
+    }
+
+    func call(_ ctx: PxModuleContext, _ method: String, _ args: [Any], _ reply: @escaping PxReply) {
+        switch method {
+        case "getUptime": reply(Int(ProcessInfo.processInfo.systemUptime * 1000), nil)
+        case "isRooted": reply(Self.looksJailbroken, nil)
+        default: reply(nil, "Device has no method '\(method)'")
+        }
+    }
+}

pyxpo_device-0.1.0a1/pyxpo_device/pyxpo-module.json

@@ -0,0 +1,15 @@
+{
+  "schemaVersion": 1,
+  "nativeContract": 2,
+  "name": "device",
+  "native": "Device",
+  "ios": {
+    "classes": ["DeviceModule"]
+  },
+  "android": {
+    "namespace": "dev.pyxpo.modules.device",
+    "classes": ["dev.pyxpo.modules.device.DeviceModule"],
+    "dependencies": [],
+    "minSdk": 24
+  }
+}

pyxpo_device-0.1.0a1/pyxpo_device.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: pyxpo-device
+Version: 0.1.0a1
+Summary: Device facts for pyxpo apps: brand, model, OS, memory, device type (expo-device shape).
+Author: Vishal Chaubey
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pyxpo/pyxpo/tree/main/packages/device
+Project-URL: Issues, https://github.com/pyxpo/pyxpo/issues
+Keywords: pyxpo,pyxpo-module,mobile,android,ios
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyxpo<0.2,>=0.1.0a2
+Dynamic: license-file
+
+# pyxpo-device
+
+Facts about the device a [pyxpo](https://github.com/pyxpo/pyxpo) app runs on: brand, model, OS, memory and
+device type. The API follows [expo-device](https://docs.expo.dev/versions/latest/sdk/device/).
+
+```sh
+pip install pyxpo-device
+```
+
+```toml
+[tool.pyxpo]
+modules = ["device"]
+```
+
+```python
+import pyxpo_device as Device
+
+print(Device.brand, Device.model_name, Device.os_name, Device.os_version)
+if Device.device_type == Device.DeviceType.TABLET:
+    ...
+uptime_ms = await Device.get_uptime_async()
+```
+
+Every name also has its expo-device spelling (`Device.modelName`, `Device.getUptimeAsync`).
+
+## Constants
+
+Read once at app start, no bridge round trip. `None` where a platform has no value.
+
+| Name | iOS | Android |
+| --- | --- | --- |
+| `is_device` | False on the Simulator | False on an emulator (best-effort check) |
+| `brand`, `manufacturer` | `"Apple"` | `Build.BRAND`, `Build.MANUFACTURER` |
+| `model_name` | Marketing name for known iPhones, else the identifier | `Build.MODEL` |
+| `model_id` | Identifier, for example `"iPhone17,3"` | None |
+| `design_name`, `product_name` | None | `Build.DEVICE`, `Build.PRODUCT` |
+| `device_year_class` | Release year of known iPhones | None |
+| `total_memory` | Bytes of RAM | Bytes of RAM |
+| `supported_cpu_architectures` | `["arm64"]` | `Build.SUPPORTED_ABIS` |
+| `os_name` | `"iOS"` or `"iPadOS"` | `"Android"` |
+| `os_version` | For example `"26.0"` | For example `"15"` |
+| `os_build_id`, `os_internal_build_id` | Kernel OS build | `Build.DISPLAY`, `Build.ID` |
+| `os_build_fingerprint`, `platform_api_level` | None | `Build.FINGERPRINT`, API level |
+| `device_name` | `UIDevice.name` (a generic name on iOS 16+) | Device name setting, else the model |
+| `device_type` | `DeviceType` from the interface idiom | `DeviceType` from TV mode and screen width (600dp+ = tablet) |
+
+On the desktop the values come from Python's `platform` module and `device_type` is `DESKTOP`.
+
+## Functions
+
+- `get_device_type_async()` -> `DeviceType`
+- `get_uptime_async()` -> milliseconds since boot, not counting deep sleep
+- `get_max_memory_async()` -> Android: the runtime's memory limit in bytes; elsewhere `MAX_SAFE_INTEGER`
+- `is_rooted_experimental_async()` -> best-effort jailbreak or root check. Easy to fool; never use it for security.
+- `is_side_loading_enabled_async()` -> Android: whether the app may install apps (needs `REQUEST_INSTALL_PACKAGES` on Android 8+)
+- `get_platform_features_async()` -> Android system feature names; `[]` elsewhere
+- `has_platform_feature_async(feature)` -> Android: for example `"android.hardware.camera"`; `False` elsewhere
+
+## Permissions
+
+None.

pyxpo_device-0.1.0a1/pyxpo_device.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+pyxpo_device/__init__.py
+pyxpo_device/py.typed
+pyxpo_device/pyxpo-module.json
+pyxpo_device.egg-info/PKG-INFO
+pyxpo_device.egg-info/SOURCES.txt
+pyxpo_device.egg-info/dependency_links.txt
+pyxpo_device.egg-info/entry_points.txt
+pyxpo_device.egg-info/requires.txt
+pyxpo_device.egg-info/top_level.txt
+pyxpo_device/android/src/main/AndroidManifest.xml
+pyxpo_device/android/src/main/java/dev/pyxpo/modules/device/DeviceModule.kt
+pyxpo_device/ios/DeviceModule.swift

pyxpo_device-0.1.0a1/pyxpo_device.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyxpo_device-0.1.0a1/pyxpo_device.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pyxpo.modules]
+device = pyxpo_device

pyxpo_device-0.1.0a1/pyxpo_device.egg-info/requires.txt

@@ -0,0 +1 @@
+pyxpo<0.2,>=0.1.0a2

pyxpo_device-0.1.0a1/pyxpo_device.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyxpo_device

pyxpo_device-0.1.0a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+