pyxpo-network 0.1.0a1__tar.gz

pyxpo_network-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_network-0.1.0a1/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: pyxpo-network
+Version: 0.1.0a1
+Summary: Network state, IP address and connectivity changes: the expo-network API for pyxpo.
+Author: Vishal Chaubey
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pyxpo/pyxpo/tree/main/packages/network
+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-network
+
+Network state, IP address and connectivity changes for [pyxpo](https://github.com/pyxpo/pyxpo) apps. The
+API follows [expo-network](https://docs.expo.dev/versions/latest/sdk/network/).
+
+```sh
+pip install pyxpo-network
+```
+
+```toml
+[tool.pyxpo]
+modules = ["network"]
+```
+
+```python
+import pyxpo_network as Network
+
+state = await Network.get_network_state_async()
+print(state.type, state.is_connected, state.is_internet_reachable)   # NetworkStateType.WIFI True True
+print(await Network.get_ip_address_async())                          # 192.168.1.20
+
+sub = Network.add_network_state_listener(lambda s: print("now", s.type))
+sub.remove()
+
+
+def OfflineBanner():
+    state = Network.use_network_state()     # re-renders on every change
+    if state.is_connected is False:
+        return Text("You are offline")
+```
+
+Every name also has its expo-network spelling (`Network.getNetworkStateAsync`, `Network.useNetworkState`).
+`NetworkState` accepts Expo's camelCase keys too (`state["isInternetReachable"]`), and `to_dict()` gives the
+camelCase dict.
+
+## Functions
+
+| Function | Returns | Platforms |
+| --- | --- | --- |
+| `get_network_state_async()` | `NetworkState` | all |
+| `get_ip_address_async()` | `str`, the IPv4 address; `"0.0.0.0"` without a network | all |
+| `is_airplane_mode_enabled_async()` | `bool` | Android |
+| `add_network_state_listener(fn)` | `Subscription` with `.remove()`. `fn(state)` runs on every change, and once with the current state when the first listener starts. | iOS, Android |
+| `use_network_state()` | `NetworkState`, updated on change | iOS, Android |
+
+## `NetworkState`
+
+| Field | Notes |
+| --- | --- |
+| `type` | `NetworkStateType`: `NONE`, `UNKNOWN`, `CELLULAR`, `WIFI`, `BLUETOOTH`, `ETHERNET`, `WIMAX`, `VPN`, `OTHER`. |
+| `is_connected` | There is an active network. |
+| `is_internet_reachable` | Android: the system validated internet access. iOS: the path is satisfied. |
+
+## Platforms
+
+- iOS 15+: `NWPathMonitor` and `getifaddrs`.
+- Android 7 (API 24)+: `ConnectivityManager`. Adds the `ACCESS_NETWORK_STATE` permission (granted at install).
+- Desktop: `UNKNOWN` when the machine has a route out, else `NONE`. No change events.

pyxpo_network-0.1.0a1/README.md

@@ -0,0 +1,58 @@
+# pyxpo-network
+
+Network state, IP address and connectivity changes for [pyxpo](https://github.com/pyxpo/pyxpo) apps. The
+API follows [expo-network](https://docs.expo.dev/versions/latest/sdk/network/).
+
+```sh
+pip install pyxpo-network
+```
+
+```toml
+[tool.pyxpo]
+modules = ["network"]
+```
+
+```python
+import pyxpo_network as Network
+
+state = await Network.get_network_state_async()
+print(state.type, state.is_connected, state.is_internet_reachable)   # NetworkStateType.WIFI True True
+print(await Network.get_ip_address_async())                          # 192.168.1.20
+
+sub = Network.add_network_state_listener(lambda s: print("now", s.type))
+sub.remove()
+
+
+def OfflineBanner():
+    state = Network.use_network_state()     # re-renders on every change
+    if state.is_connected is False:
+        return Text("You are offline")
+```
+
+Every name also has its expo-network spelling (`Network.getNetworkStateAsync`, `Network.useNetworkState`).
+`NetworkState` accepts Expo's camelCase keys too (`state["isInternetReachable"]`), and `to_dict()` gives the
+camelCase dict.
+
+## Functions
+
+| Function | Returns | Platforms |
+| --- | --- | --- |
+| `get_network_state_async()` | `NetworkState` | all |
+| `get_ip_address_async()` | `str`, the IPv4 address; `"0.0.0.0"` without a network | all |
+| `is_airplane_mode_enabled_async()` | `bool` | Android |
+| `add_network_state_listener(fn)` | `Subscription` with `.remove()`. `fn(state)` runs on every change, and once with the current state when the first listener starts. | iOS, Android |
+| `use_network_state()` | `NetworkState`, updated on change | iOS, Android |
+
+## `NetworkState`
+
+| Field | Notes |
+| --- | --- |
+| `type` | `NetworkStateType`: `NONE`, `UNKNOWN`, `CELLULAR`, `WIFI`, `BLUETOOTH`, `ETHERNET`, `WIMAX`, `VPN`, `OTHER`. |
+| `is_connected` | There is an active network. |
+| `is_internet_reachable` | Android: the system validated internet access. iOS: the path is satisfied. |
+
+## Platforms
+
+- iOS 15+: `NWPathMonitor` and `getifaddrs`.
+- Android 7 (API 24)+: `ConnectivityManager`. Adds the `ACCESS_NETWORK_STATE` permission (granted at install).
+- Desktop: `UNKNOWN` when the machine has a route out, else `NONE`. No change events.

pyxpo_network-0.1.0a1/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyxpo-network"
+dynamic = ["version"]
+description = "Network state, IP address and connectivity changes: the expo-network API for pyxpo."
+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/network"
+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"]
+network = "pyxpo_network"
+
+[tool.setuptools]
+packages = ["pyxpo_network"]
+
+[tool.setuptools.dynamic]
+version = { attr = "pyxpo_network.__version__" }
+
+[tool.setuptools.package-data]
+pyxpo_network = ["pyxpo-module.json", "py.typed", "ios/**/*", "android/**/*"]
+
+[tool.setuptools.exclude-package-data]
+"*" = ["__pycache__", "*.pyc", ".DS_Store"]

pyxpo_network-0.1.0a1/pyxpo_network/__init__.py

@@ -0,0 +1,185 @@
+"""Network state, IP address and connectivity changes: the expo-network API.
+
+    import pyxpo_network as Network
+
+    state = await Network.get_network_state_async()    # or Network.getNetworkStateAsync()
+    state.type, state.is_connected, state.is_internet_reachable
+    ip = await Network.get_ip_address_async()          # "192.168.1.20", or "0.0.0.0" without a network
+
+    sub = Network.add_network_state_listener(lambda s: print(s.type))
+    sub.remove()
+
+    def Status():
+        state = Network.use_network_state()            # re-renders on every change
+
+On the desktop the state is a best guess (`UNKNOWN` or `NONE`) from whether the machine has a route out.
+"""
+from __future__ import annotations
+
+import socket
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional
+
+from pyxpo.module_api import NotSupportedError, call, on_event, platform, require_linked, require_supported
+
+__version__ = "0.1.0a1"
+
+_EVENT = "Network.state"
+
+
+class NetworkStateType(str, Enum):
+    NONE = "NONE"
+    UNKNOWN = "UNKNOWN"
+    CELLULAR = "CELLULAR"
+    WIFI = "WIFI"
+    BLUETOOTH = "BLUETOOTH"
+    ETHERNET = "ETHERNET"
+    WIMAX = "WIMAX"
+    VPN = "VPN"
+    OTHER = "OTHER"
+
+
+_CAMEL = {"type": "type", "isConnected": "is_connected", "isInternetReachable": "is_internet_reachable"}
+
+
+@dataclass(frozen=True)
+class NetworkState:
+    """`is_connected`: there is an active network. `is_internet_reachable`: the system checked that it reaches
+    the internet. Either is None when unknown."""
+    type: NetworkStateType = NetworkStateType.UNKNOWN
+    is_connected: Optional[bool] = None
+    is_internet_reachable: Optional[bool] = None
+
+    def __getitem__(self, key: str) -> Any:
+        if key not in _CAMEL:
+            raise KeyError(key)
+        return getattr(self, _CAMEL[key])
+
+    def to_dict(self) -> Dict[str, Any]:
+        """The state with Expo's camelCase keys; `type` is the plain string."""
+        return {"type": self.type.value, "isConnected": self.is_connected, "isInternetReachable": self.is_internet_reachable}
+
+
+def _state(raw: Dict[str, Any]) -> NetworkState:
+    t = raw.get("type")
+    kind = NetworkStateType(t) if t in NetworkStateType._value2member_map_ else NetworkStateType.UNKNOWN
+    return NetworkState(kind, raw.get("isConnected"), raw.get("isInternetReachable"))
+
+
+def _desktop_ip() -> Optional[str]:
+    # A UDP connect picks the outgoing interface without sending anything.
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        s.connect(("192.0.2.1", 9))
+        ip = s.getsockname()[0]
+        return None if ip.startswith("0.") else ip
+    except OSError:
+        return None
+    finally:
+        s.close()
+
+
+def _native() -> bool:
+    if platform() == "desktop":
+        return False
+    require_linked("Network", "network", package="pyxpo-network")
+    return True
+
+
+async def get_network_state_async() -> NetworkState:
+    """The current network: its type, whether it is connected and whether the internet is reachable."""
+    if not _native():
+        up = _desktop_ip() is not None
+        return NetworkState(NetworkStateType.UNKNOWN if up else NetworkStateType.NONE, up, None if up else False)
+    return _state(await call("Network", "getState", reply=True) or {})
+
+
+async def get_ip_address_async() -> str:
+    """The device's IPv4 address on the active network, "0.0.0.0" when there is none."""
+    if not _native():
+        return _desktop_ip() or "0.0.0.0"
+    return str(await call("Network", "getIpAddress", reply=True) or "0.0.0.0")
+
+
+async def is_airplane_mode_enabled_async() -> bool:
+    """Android: whether airplane mode is on. Raises `NotSupportedError` on iOS and the desktop."""
+    require_supported("is_airplane_mode_enabled_async", ios=False)
+    if not _native():
+        raise NotSupportedError("is_airplane_mode_enabled_async needs Android")
+    return bool(await call("Network", "isAirplaneModeEnabled", reply=True))
+
+
+class Subscription:
+    def __init__(self, fn: Callable[[NetworkState], Any]) -> None:
+        self._fn: Optional[Callable[[NetworkState], Any]] = fn
+
+    def remove(self) -> None:
+        """Stops this listener. Safe to call twice."""
+        if self._fn is None:
+            return
+        _listeners.remove(self._fn)
+        self._fn = None
+        if not _listeners:
+            _stop()
+
+
+_listeners: List[Callable[[NetworkState], Any]] = []
+_off: Optional[Callable[[], None]] = None
+_last: Optional[NetworkState] = None
+
+
+def _on_state(raw: Any) -> None:
+    global _last
+    _last = _state(raw or {})
+    for fn in list(_listeners):
+        fn(_last)
+
+
+def _stop() -> None:
+    global _off, _last
+    if _off is not None:
+        _off()
+        _off = None
+        _last = None
+        call("Network", "stopObserving")
+
+
+def add_network_state_listener(listener: Callable[[NetworkState], Any]) -> Subscription:
+    """Calls `listener(state)` on every network change, and once with the current state after the first
+    listener starts. Returns a subscription; call `.remove()` to stop. No events on the desktop."""
+    global _off
+    _listeners.append(listener)
+    if _off is None and _native():
+        _off = on_event(_EVENT, _on_state)
+        call("Network", "startObserving")
+    return Subscription(listener)
+
+
+def use_network_state() -> NetworkState:
+    """The current network state; the component re-renders when it changes."""
+    from pyxpo import use_effect, use_state
+    state, set_state = use_state(lambda: _last or NetworkState())
+
+    def subscribe() -> Callable[[], None]:
+        sub = add_network_state_listener(set_state)
+        if _last is not None:
+            set_state(_last)
+        return sub.remove
+
+    use_effect(subscribe, [])
+    return state
+
+
+getNetworkStateAsync = get_network_state_async
+getIpAddressAsync = get_ip_address_async
+isAirplaneModeEnabledAsync = is_airplane_mode_enabled_async
+addNetworkStateListener = add_network_state_listener
+useNetworkState = use_network_state
+
+__all__ = [
+    "NetworkStateType", "NetworkState", "Subscription", "get_network_state_async", "get_ip_address_async",
+    "is_airplane_mode_enabled_async", "add_network_state_listener", "use_network_state",
+    "getNetworkStateAsync", "getIpAddressAsync", "isAirplaneModeEnabledAsync", "addNetworkStateListener",
+    "useNetworkState",
+]

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

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

pyxpo_network-0.1.0a1/pyxpo_network/android/src/main/java/dev/pyxpo/modules/network/NetworkModule.kt

@@ -0,0 +1,100 @@
+package dev.pyxpo.modules.network
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.LinkProperties
+import android.net.Network
+import android.net.NetworkCapabilities
+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.net.Inet4Address
+import java.net.NetworkInterface
+
+/** expo-network on Android: `ConnectivityManager` state, the default network callback and airplane mode. */
+class NetworkModule : PxModule() {
+    override val name = "Network"
+
+    private var callback: ConnectivityManager.NetworkCallback? = null
+
+    private fun cm(c: Context) = c.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+    private fun state(caps: NetworkCapabilities?): Map<String, Any?> {
+        if (caps == null) return mapOf("type" to "NONE", "isConnected" to false, "isInternetReachable" to false)
+        val type = when {
+            caps.hasTransport(NetworkCapabilities.TRANSPORT_VPN) -> "VPN"
+            caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> "WIFI"
+            caps.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> "CELLULAR"
+            caps.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> "ETHERNET"
+            caps.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH) -> "BLUETOOTH"
+            else -> "UNKNOWN"
+        }
+        return mapOf(
+            "type" to type,
+            "isConnected" to caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET),
+            "isInternetReachable" to caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED),
+        )
+    }
+
+    private fun current(c: Context): Map<String, Any?> {
+        val m = cm(c)
+        return state(m.activeNetwork?.let { m.getNetworkCapabilities(it) })
+    }
+
+    private fun ipAddress(c: Context): String {
+        val m = cm(c)
+        m.activeNetwork?.let { m.getLinkProperties(it) }?.linkAddresses
+            ?.map { it.address }?.firstOrNull { it is Inet4Address && !it.isLoopbackAddress }
+            ?.let { return it.hostAddress ?: "0.0.0.0" }
+        return try {
+            NetworkInterface.getNetworkInterfaces().toList().filter { it.isUp && !it.isLoopback }
+                .flatMap { it.inetAddresses.toList() }.firstOrNull { it is Inet4Address }?.hostAddress ?: "0.0.0.0"
+        } catch (_: Exception) { "0.0.0.0" }
+    }
+
+    override fun call(ctx: PxModuleContext, method: String, args: JSONArray, reply: PxReply) {
+        val c = ctx.activity.applicationContext
+        when (method) {
+            "getState" -> reply(current(c), null)
+            "getIpAddress" -> reply(ipAddress(c), null)
+            "isAirplaneModeEnabled" -> reply(Settings.Global.getInt(c.contentResolver, Settings.Global.AIRPLANE_MODE_ON, 0) != 0, null)
+            "startObserving" -> { start(ctx, c); reply(null, null) }
+            "stopObserving" -> { stop(c); reply(null, null) }
+            else -> reply(null, "Network has no method '$method'")
+        }
+    }
+
+    /** The default-network callback reports the current network right after it is registered. */
+    private fun start(ctx: PxModuleContext, c: Context) {
+        if (callback != null) {
+            ctx.emit("Network.state", current(c))
+            return
+        }
+        val cb = object : ConnectivityManager.NetworkCallback() {
+            override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) {
+                ctx.emit("Network.state", state(caps))
+            }
+            override fun onLost(network: Network) {
+                ctx.emit("Network.state", state(null))
+            }
+            override fun onUnavailable() {
+                ctx.emit("Network.state", state(null))
+            }
+        }
+        callback = cb
+        try {
+            cm(c).registerDefaultNetworkCallback(cb)
+        } catch (e: Exception) {
+            callback = null
+            ctx.emit("Network.state", current(c))
+        }
+    }
+
+    private fun stop(c: Context) {
+        val cb = callback ?: return
+        callback = null
+        try { cm(c).unregisterNetworkCallback(cb) } catch (_: Exception) {}
+    }
+}

pyxpo_network-0.1.0a1/pyxpo_network/ios/NetworkModule.swift

@@ -0,0 +1,98 @@
+import Foundation
+import Network
+
+/// expo-network on iOS. One `NWPathMonitor` runs from the first call; all of its state lives on `queue`.
+final class NetworkModule: PxModule {
+    static let moduleName = "Network"
+
+    private let queue = DispatchQueue(label: "dev.pyxpo.network")
+    private var monitor: NWPathMonitor?
+    private var path: NWPath?
+    private var waiting: [PxReply] = []
+    private weak var observer: PxModuleContext?
+
+    required init() {}
+
+    deinit { monitor?.cancel() }
+
+    private func start() {
+        guard monitor == nil else { return }
+        let m = NWPathMonitor()
+        m.pathUpdateHandler = { [weak self] p in self?.update(p) }
+        monitor = m
+        m.start(queue: queue)
+    }
+
+    /// On `queue`.
+    private func update(_ p: NWPath) {
+        path = p
+        let state = Self.state(p)
+        let replies = waiting
+        waiting = []
+        replies.forEach { $0(state, nil) }
+        observer?.emit("Network.state", state)
+    }
+
+    private static func state(_ p: NWPath) -> [String: Any] {
+        let up = p.status == .satisfied
+        let type: String
+        if !up { type = "NONE" }
+        else if p.usesInterfaceType(.wifi) { type = "WIFI" }
+        else if p.usesInterfaceType(.cellular) { type = "CELLULAR" }
+        else if p.usesInterfaceType(.wiredEthernet) { type = "ETHERNET" }
+        else if p.usesInterfaceType(.other) {
+            // Virtual interfaces: utun/ipsec/ppp are VPN tunnels.
+            let vpn = p.availableInterfaces.contains { i in
+                i.type == .other && ["utun", "ipsec", "ppp", "tap", "tun"].contains { i.name.hasPrefix($0) }
+            }
+            type = vpn ? "VPN" : "OTHER"
+        }
+        else { type = "UNKNOWN" }
+        return ["type": type, "isConnected": up, "isInternetReachable": up]
+    }
+
+    /// The IPv4 address of the interface in use: Wi-Fi (en0) first, then cellular (pdp_ip0), then any other.
+    private static func ipAddress() -> String {
+        var found: [String: String] = [:]
+        var head: UnsafeMutablePointer<ifaddrs>?
+        guard getifaddrs(&head) == 0, let first = head else { return "0.0.0.0" }
+        defer { freeifaddrs(head) }
+        var cur: UnsafeMutablePointer<ifaddrs>? = first
+        while let ifa = cur {
+            defer { cur = ifa.pointee.ifa_next }
+            let flags = Int32(ifa.pointee.ifa_flags)
+            guard let addr = ifa.pointee.ifa_addr, addr.pointee.sa_family == UInt8(AF_INET),
+                  flags & IFF_UP != 0, flags & IFF_LOOPBACK == 0 else { continue }
+            var host = [CChar](repeating: 0, count: Int(NI_MAXHOST))
+            guard getnameinfo(addr, socklen_t(addr.pointee.sa_len), &host, socklen_t(host.count), nil, 0, NI_NUMERICHOST) == 0 else { continue }
+            let name = String(cString: ifa.pointee.ifa_name)
+            if found[name] == nil { found[name] = String(cString: host) }
+        }
+        if let ip = found["en0"] ?? found["pdp_ip0"] { return ip }
+        return found.sorted { $0.key < $1.key }.first?.value ?? "0.0.0.0"
+    }
+
+    func call(_ ctx: PxModuleContext, _ method: String, _ args: [Any], _ reply: @escaping PxReply) {
+        switch method {
+        case "getState":
+            start()
+            queue.async {
+                if let p = self.path { reply(Self.state(p), nil) } else { self.waiting.append(reply) }
+            }
+        case "getIpAddress":
+            DispatchQueue.global(qos: .userInitiated).async { reply(Self.ipAddress(), nil) }
+        case "startObserving":
+            start()
+            queue.async {
+                self.observer = ctx
+                if let p = self.path { ctx.emit("Network.state", Self.state(p)) }
+            }
+            reply(nil, nil)
+        case "stopObserving":
+            queue.async { self.observer = nil }
+            reply(nil, nil)
+        default:
+            reply(nil, "Network has no method '\(method)'")
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "nativeContract": 1,
+  "name": "network",
+  "native": "Network",
+  "ios": {
+    "classes": ["NetworkModule"]
+  },
+  "android": {
+    "namespace": "dev.pyxpo.modules.network",
+    "classes": ["dev.pyxpo.modules.network.NetworkModule"],
+    "minSdk": 24
+  }
+}

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

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: pyxpo-network
+Version: 0.1.0a1
+Summary: Network state, IP address and connectivity changes: the expo-network API for pyxpo.
+Author: Vishal Chaubey
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pyxpo/pyxpo/tree/main/packages/network
+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-network
+
+Network state, IP address and connectivity changes for [pyxpo](https://github.com/pyxpo/pyxpo) apps. The
+API follows [expo-network](https://docs.expo.dev/versions/latest/sdk/network/).
+
+```sh
+pip install pyxpo-network
+```
+
+```toml
+[tool.pyxpo]
+modules = ["network"]
+```
+
+```python
+import pyxpo_network as Network
+
+state = await Network.get_network_state_async()
+print(state.type, state.is_connected, state.is_internet_reachable)   # NetworkStateType.WIFI True True
+print(await Network.get_ip_address_async())                          # 192.168.1.20
+
+sub = Network.add_network_state_listener(lambda s: print("now", s.type))
+sub.remove()
+
+
+def OfflineBanner():
+    state = Network.use_network_state()     # re-renders on every change
+    if state.is_connected is False:
+        return Text("You are offline")
+```
+
+Every name also has its expo-network spelling (`Network.getNetworkStateAsync`, `Network.useNetworkState`).
+`NetworkState` accepts Expo's camelCase keys too (`state["isInternetReachable"]`), and `to_dict()` gives the
+camelCase dict.
+
+## Functions
+
+| Function | Returns | Platforms |
+| --- | --- | --- |
+| `get_network_state_async()` | `NetworkState` | all |
+| `get_ip_address_async()` | `str`, the IPv4 address; `"0.0.0.0"` without a network | all |
+| `is_airplane_mode_enabled_async()` | `bool` | Android |
+| `add_network_state_listener(fn)` | `Subscription` with `.remove()`. `fn(state)` runs on every change, and once with the current state when the first listener starts. | iOS, Android |
+| `use_network_state()` | `NetworkState`, updated on change | iOS, Android |
+
+## `NetworkState`
+
+| Field | Notes |
+| --- | --- |
+| `type` | `NetworkStateType`: `NONE`, `UNKNOWN`, `CELLULAR`, `WIFI`, `BLUETOOTH`, `ETHERNET`, `WIMAX`, `VPN`, `OTHER`. |
+| `is_connected` | There is an active network. |
+| `is_internet_reachable` | Android: the system validated internet access. iOS: the path is satisfied. |
+
+## Platforms
+
+- iOS 15+: `NWPathMonitor` and `getifaddrs`.
+- Android 7 (API 24)+: `ConnectivityManager`. Adds the `ACCESS_NETWORK_STATE` permission (granted at install).
+- Desktop: `UNKNOWN` when the machine has a route out, else `NONE`. No change events.

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[pyxpo.modules]
+network = pyxpo_network

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

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

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

@@ -0,0 +1 @@
+pyxpo_network

pyxpo_network-0.1.0a1/setup.cfg

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