pythonnative 0.8.0__tar.gz → 0.9.0__tar.gz

{pythonnative-0.8.0/src/pythonnative.egg-info → pythonnative-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.8.0
+Version: 0.9.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License

{pythonnative-0.8.0 → pythonnative-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.8.0"
+version = "0.9.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }

{pythonnative-0.8.0 → pythonnative-0.9.0}/src/pythonnative/__init__.py

@@ -14,7 +14,7 @@ Public API::
         )
 """
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"
 
 from .components import (
     ActivityIndicator,

pythonnative-0.9.0/src/pythonnative/_ios_log.py

@@ -0,0 +1,94 @@
+"""Route Python ``sys.stdout``/``sys.stderr`` through fd 2 on iOS.
+
+Why
+---
+When an app is launched via ``xcrun simctl launch --console-pty`` (what
+``pn run ios`` does), the simulator attaches the caller's terminal to
+the app's stderr, which is the same channel ``NSLog`` / ``os_log``
+writes to. Python ``print()`` calls, however, go to ``sys.stdout``
+(fd 1), and for reasons specific to how CPython's embedded framework
+is started on the iOS Simulator that descriptor does not reach the
+attached console. As a result users see Swift-side ``NSLog`` output
+but never their own ``print()`` output.
+
+Redirecting ``sys.stdout`` / ``sys.stderr`` at a Python level to write
+straight to fd 2 is a small, reliable fix: fd 2 *is* visible to
+``simctl`` (that's exactly how ``NSLog`` reaches the terminal), so
+Python output lands next to the Swift logs with correct ordering.
+
+This module is intentionally self-contained: no rubicon-objc or
+platform-specific C bindings required, so it's safe to import early
+during ``pythonnative`` package initialization.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Iterable
+
+_STDERR_FD = 2
+
+
+class _StderrStream:
+    """Minimal text-mode file-like that writes UTF-8 bytes to fd 2.
+
+    It's write-through (no buffering) so a ``print()`` call appears in
+    the terminal immediately, which matches user expectations for an
+    interactive "run on simulator" log stream.
+    """
+
+    encoding = "utf-8"
+    errors = "replace"
+    mode = "w"
+    name = "<stderr>"
+
+    def write(self, s: str) -> int:
+        if not s:
+            return 0
+        data = s.encode(self.encoding, self.errors)
+        try:
+            return os.write(_STDERR_FD, data)
+        except OSError:
+            return 0
+
+    def writelines(self, lines: Iterable[str]) -> None:
+        for line in lines:
+            self.write(line)
+
+    def flush(self) -> None:
+        # os.write is unbuffered; nothing to flush.
+        return None
+
+    def isatty(self) -> bool:
+        try:
+            return os.isatty(_STDERR_FD)
+        except OSError:
+            return False
+
+    def fileno(self) -> int:
+        return _STDERR_FD
+
+    def close(self) -> None:
+        # Don't actually close fd 2.
+        return None
+
+    @property
+    def closed(self) -> bool:
+        return False
+
+
+_installed = False
+
+
+def install() -> None:
+    """Swap ``sys.stdout`` / ``sys.stderr`` for fd-2 writers.
+
+    Safe to call multiple times; only the first call has effect.
+    """
+    global _installed
+    if _installed:
+        return
+    sys.stdout = _StderrStream()
+    sys.stderr = _StderrStream()
+    _installed = True

{pythonnative-0.8.0 → pythonnative-0.9.0}/src/pythonnative/cli/pn.py

@@ -246,6 +246,55 @@ def _read_requirements(requirements_path: str) -> list[str]:
     return result
 
 
+ANDROID_LOGCAT_FILTERS: list[str] = [
+    "python.stdout:V",
+    "python.stderr:V",
+    "MainActivity:V",
+    "PageFragment:V",
+    "Navigator:V",
+    "PythonNative:V",
+    "AndroidRuntime:E",
+    "System.err:W",
+    "*:S",
+]
+
+IOS_BUNDLE_ID: str = "com.pythonnative.ios-template"
+
+
+def _start_android_log_stream() -> Optional[subprocess.Popen]:
+    """Clear logcat and stream Python-relevant log tags to the terminal.
+
+    Returns the ``adb logcat`` subprocess, or ``None`` when ``adb`` is
+    unavailable. Python's ``print()`` output reaches logcat via Chaquopy,
+    which redirects ``sys.stdout``/``sys.stderr`` to the ``python.stdout``
+    and ``python.stderr`` tags.
+    """
+    try:
+        subprocess.run(["adb", "logcat", "-c"], check=False, capture_output=True)
+    except FileNotFoundError:
+        print("Note: 'adb' not found on PATH; skipping log streaming.")
+        return None
+    try:
+        proc = subprocess.Popen(["adb", "logcat", *ANDROID_LOGCAT_FILTERS])
+    except FileNotFoundError:
+        return None
+    print("Streaming Python logs from device (Ctrl+C to stop)...")
+    return proc
+
+
+def _terminate_subprocess(proc: Optional[subprocess.Popen]) -> None:
+    """Politely stop a subprocess, escalating to SIGKILL if needed."""
+    if proc is None:
+        return
+    if proc.poll() is not None:
+        return
+    proc.terminate()
+    try:
+        proc.wait(timeout=3)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+
+
 def run_project(args: argparse.Namespace) -> None:
     """
     Run the specified project.
@@ -254,6 +303,7 @@ def run_project(args: argparse.Namespace) -> None:
     platform: str = args.platform
     prepare_only: bool = getattr(args, "prepare_only", False)
     hot_reload: bool = getattr(args, "hot_reload", False)
+    show_logs: bool = not getattr(args, "no_logs", False)
 
     # Read project configuration and save project root before any chdir
     project_dir: str = os.getcwd()
@@ -371,6 +421,18 @@ def run_project(args: argparse.Namespace) -> None:
             ],
             check=True,
         )
+
+        # Stream Python logs from logcat unless the user opted out or requested
+        # hot-reload (hot-reload handles its own log tailing below).
+        if show_logs and not hot_reload:
+            logcat_proc = _start_android_log_stream()
+            if logcat_proc is not None:
+                try:
+                    logcat_proc.wait()
+                except KeyboardInterrupt:
+                    print()
+                    _terminate_subprocess(logcat_proc)
+                    print("Stopped log streaming.")
     elif platform == "ios":
         # Attempt to build and run on iOS Simulator (best-effort)
         ios_project_dir: str = os.path.join(build_dir, "ios_template")
@@ -640,22 +702,64 @@ def run_project(args: argparse.Namespace) -> None:
                     return
 
                 udid = preferred.get("udid")
-                # Boot (no-op if already booted)
-                subprocess.run(["xcrun", "simctl", "boot", udid], check=False)
-                # Install and launch
+                # Boot (no-op if already booted). simctl returns non-zero and
+                # prints to stderr when the device is already Booted; we
+                # don't care about that case, so swallow its output.
+                subprocess.run(["xcrun", "simctl", "boot", udid], check=False, capture_output=True)
+                # Install
                 subprocess.run(["xcrun", "simctl", "install", udid, app_path], check=False)
-                subprocess.run(["xcrun", "simctl", "launch", udid, "com.pythonnative.ios-template"], check=False)
-                print("Launched iOS app on Simulator (best-effort).")
+                if show_logs and not hot_reload:
+                    # Attach the app's stdout/stderr to this terminal so Python
+                    # print() calls and exceptions are visible. SIMCTL_CHILD_*
+                    # env vars are forwarded to the launched process.
+                    sim_env = os.environ.copy()
+                    sim_env["SIMCTL_CHILD_PYTHONUNBUFFERED"] = "1"
+                    print("Launched iOS app on Simulator. Streaming logs (Ctrl+C to stop)...")
+                    try:
+                        subprocess.run(
+                            [
+                                "xcrun",
+                                "simctl",
+                                "launch",
+                                "--console-pty",
+                                "--terminate-running-process",
+                                udid,
+                                IOS_BUNDLE_ID,
+                            ],
+                            env=sim_env,
+                            check=False,
+                        )
+                    except KeyboardInterrupt:
+                        print()
+                        subprocess.run(
+                            ["xcrun", "simctl", "terminate", udid, IOS_BUNDLE_ID],
+                            check=False,
+                            capture_output=True,
+                        )
+                        print("Stopped log streaming.")
+                else:
+                    subprocess.run(["xcrun", "simctl", "launch", udid, IOS_BUNDLE_ID], check=False)
+                    print("Launched iOS app on Simulator (best-effort).")
+                    if show_logs and hot_reload:
+                        print(
+                            "Note: live Python log streaming on iOS is disabled while --hot-reload is active; "
+                            "use Console.app or Xcode to view logs."
+                        )
             except Exception:
                 print("Failed to auto-run on Simulator; open the project in Xcode to run.")
 
     # Hot-reload file watcher
     if hot_reload and not prepare_only:
-        _run_hot_reload(platform, project_dir, build_dir)
+        _run_hot_reload(platform, project_dir, build_dir, show_logs=show_logs)
+
 
+def _run_hot_reload(platform: str, project_dir: str, build_dir: str, show_logs: bool = True) -> None:
+    """Watch ``app/`` for changes and push updated files to the device.
 
-def _run_hot_reload(platform: str, project_dir: str, build_dir: str) -> None:
-    """Watch ``app/`` for changes and push updated files to the device."""
+    When ``show_logs`` is true and targeting Android, ``adb logcat`` is
+    streamed in parallel so Python print/exception output stays visible
+    alongside hot-reload notifications.
+    """
     from .hot_reload import FileWatcher
 
     app_dir = os.path.join(project_dir, "app")
@@ -673,12 +777,23 @@ def _run_hot_reload(platform: str, project_dir: str, build_dir: str) -> None:
     print("[hot-reload] Watching app/ for changes. Press Ctrl+C to stop.")
     watcher = FileWatcher(app_dir, on_change, interval=1.0)
     watcher.start()
+
+    logcat_proc: Optional[subprocess.Popen] = None
+    if show_logs and platform == "android":
+        logcat_proc = _start_android_log_stream()
+
     try:
-        import time
+        if logcat_proc is not None:
+            logcat_proc.wait()
+        else:
+            import time
 
-        while True:
-            time.sleep(1)
+            while True:
+                time.sleep(1)
     except KeyboardInterrupt:
+        pass
+    finally:
+        _terminate_subprocess(logcat_proc)
         watcher.stop()
         print("\n[hot-reload] Stopped.")
 
@@ -721,6 +836,11 @@ def main() -> None:
         action="store_true",
         help="Watch app/ for changes and push updates to the running app",
     )
+    parser_run.add_argument(
+        "--no-logs",
+        action="store_true",
+        help="Don't attach to the app's stdout/stderr after launching (default: stream logs)",
+    )
     parser_run.set_defaults(func=run_project)
 
     # Create a new command 'clean' that calls clean_project

{pythonnative-0.8.0 → pythonnative-0.9.0}/src/pythonnative/page.py

@@ -27,7 +27,7 @@ import importlib
 import json
 from typing import Any, Dict, Optional
 
-from .utils import IS_ANDROID, set_android_context
+from .utils import IS_ANDROID, IS_IOS, set_android_context
 
 _MAX_RENDER_PASSES = 25
 
@@ -250,6 +250,21 @@ else:
     except ImportError:
         pass
 
+    # Redirect Python's stdout/stderr through fd 2 so ``print()`` output is
+    # visible via ``xcrun simctl launch --console-pty``. This runs at
+    # ``pythonnative.page`` import time, i.e. before any user page module
+    # (e.g. ``app.main_page``) is imported, so their top-level ``print()``
+    # calls are captured too. Gated on ``IS_IOS`` rather than rubicon-objc
+    # being importable, so installing the ``[ios]`` extra on macOS does
+    # not silently swap ``sys.stdout`` on a dev machine.
+    if IS_IOS:
+        try:
+            from . import _ios_log
+
+            _ios_log.install()
+        except Exception:
+            pass
+
     _IOS_PAGE_REGISTRY: _Dict[int, Any] = {}
 
     def _ios_register_page(vc_instance: Any, host_obj: Any) -> None:

{pythonnative-0.8.0 → pythonnative-0.9.0}/src/pythonnative/templates/ios_template/ios_template/ViewController.swift

@@ -27,13 +27,18 @@ class ViewController: UIViewController {
         super.viewDidLoad()
         // Ensure a visible background when created programmatically (storyboards set this automatically)
         view.backgroundColor = .systemBackground
-        NSLog("[PN][ViewController] viewDidLoad")
-        if let bundleId = Bundle.main.bundleIdentifier {
-            NSLog("[PN] Bundle Identifier: \(bundleId)")
-        }
-        NSLog("[PN] Bundle Path: \(Bundle.main.bundlePath)")
-        NSLog("[PN] Resource Path: \(Bundle.main.resourcePath ?? "nil")")
-        // Configure embedded Python if available in bundle
+
+        let firstInit = !ViewController.hasInitializedPython
+
+        // Signal to pythonnative that we're running on iOS. Read on the
+        // Python side (pythonnative.utils.IS_IOS) to gate iOS-only setup
+        // like sys.stdout redirection. Set before Python starts so it's
+        // visible to the very first import.
+        setenv("PN_PLATFORM", "ios", 1)
+
+        // Configure embedded Python if available in bundle. PYTHONHOME /
+        // PYTHONPATH only need to be set once per process, but setting them
+        // again is harmless and keeps the flow simple.
         if let resourcePath = Bundle.main.resourcePath {
             let pyStd = "\(resourcePath)/python-stdlib"
             let pyDyn = "\(resourcePath)/python-stdlib/lib-dynload"
@@ -44,8 +49,6 @@ class ViewController: UIViewController {
             }
             setenv("PYTHONHOME", pyStd, 1)
             setenv("PYTHONPATH", pyPath, 1)
-            NSLog("[PN] Set PYTHONHOME=\(pyStd)")
-            NSLog("[PN] Set PYTHONPATH=\(pyPath)")
         }
         #if canImport(PythonKit)
         // Ensure PythonKit knows where to load the Python library from when using an embedded framework.
@@ -53,34 +56,25 @@ class ViewController: UIViewController {
             let frameworkLib = "\(bundlePath)/Frameworks/Python.framework/Python"
             setenv("PYTHON_LIBRARY", frameworkLib, 1)
             if FileManager.default.fileExists(atPath: frameworkLib) {
-                if !ViewController.hasInitializedPython {
-                    NSLog("[PN] Using embedded Python lib at: \(frameworkLib)")
+                if firstInit {
                     PythonLibrary.useLibrary(at: frameworkLib)
                     ViewController.hasInitializedPython = true
-                } else {
-                    NSLog("[PN] Python library already initialized; skipping useLibrary")
                 }
                 pythonReady = true
             } else {
                 NSLog("[PN] Embedded Python library not found at: \(frameworkLib)")
             }
         }
-        NSLog("[PN] PythonKit available; attempting Python bootstrap")
         let sys = Python.import("sys")
-        NSLog("[PN] Python version: \(sys.version)")
-        NSLog("[PN] Initial sys.path: \(sys.path)")
+        if firstInit {
+            // One concise bootstrap line per process; per-page detail is left
+            // to Python-side print() statements streamed via pn run ios.
+            let shortVersion = "\(sys.version)".split(separator: "\n").first.map(String.init) ?? "\(sys.version)"
+            NSLog("[PN] Python \(shortVersion) initialized")
+        }
         if let resourcePath = Bundle.main.resourcePath {
             sys.path.append(resourcePath)
             sys.path.append("\(resourcePath)/app")
-            NSLog("[PN] Updated sys.path: \(sys.path)")
-            // List bundled resources to verify Python files are present
-            let fm = FileManager.default
-            let appDir = "\(resourcePath)/app"
-            if let entries = try? fm.contentsOfDirectory(atPath: appDir) {
-                NSLog("[PN] Contents of /app in bundle: \(entries)")
-            } else {
-                NSLog("[PN] Could not list contents of \(appDir).")
-            }
         }
         // Determine which Python page to load
         let pagePath: String = requestedPagePath ?? "app.main_page.MainPage"

{pythonnative-0.8.0 → pythonnative-0.9.0}/src/pythonnative/utils.py

@@ -5,6 +5,7 @@ importing platform-specific packages at module level.
 """
 
 import os
+import sys
 from typing import Any, Optional
 
 # ======================================================================
@@ -12,6 +13,7 @@ from typing import Any, Optional
 # ======================================================================
 
 _is_android: Optional[bool] = None
+_is_ios: Optional[bool] = None
 
 
 def _detect_android() -> bool:
@@ -27,10 +29,40 @@ def _detect_android() -> bool:
     return False
 
 
+def _detect_ios() -> bool:
+    """Detect whether we're running inside an iOS app bundle.
+
+    Signals, in priority order:
+
+    - Explicit ``PN_PLATFORM=ios`` env var (set by the iOS template's
+      ``ViewController.swift`` before Python starts). This is the
+      canonical signal and survives even on hosts where ``sys.platform``
+      is generic ``darwin``.
+    - ``sys.platform == "ios"`` (CPython 3.13+ native iOS builds).
+    - ``/CoreSimulator/Devices/`` in ``$HOME`` (iOS Simulator fallback
+      if the template signal is missing for some reason).
+
+    Crucially, having ``rubicon-objc`` importable is *not* enough:
+    developers frequently install it on macOS via the ``[ios]`` extra,
+    and treating that as iOS would cause subtle side effects
+    (e.g. stdout redirection) on desktop machines.
+    """
+    if os.environ.get("PN_PLATFORM") == "ios":
+        return True
+    if sys.platform == "ios":
+        return True
+    home = os.environ.get("HOME", "")
+    if "/CoreSimulator/Devices/" in home:
+        return True
+    return False
+
+
 def _ensure_platform_detection() -> None:
-    global _is_android
+    global _is_android, _is_ios
     if _is_android is None:
         _is_android = _detect_android()
+    if _is_ios is None:
+        _is_ios = (not _is_android) and _detect_ios()
 
 
 def _get_is_android() -> bool:
@@ -39,7 +71,14 @@ def _get_is_android() -> bool:
     return _is_android
 
 
+def _get_is_ios() -> bool:
+    _ensure_platform_detection()
+    assert _is_ios is not None
+    return _is_ios
+
+
 IS_ANDROID: bool = _get_is_android()
+IS_IOS: bool = _get_is_ios()
 
 # ======================================================================
 # Android context management

{pythonnative-0.8.0 → pythonnative-0.9.0/src/pythonnative.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.8.0
+Version: 0.9.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License

{pythonnative-0.8.0 → pythonnative-0.9.0}/src/pythonnative.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 src/pythonnative/__init__.py
+src/pythonnative/_ios_log.py
 src/pythonnative/components.py
 src/pythonnative/element.py
 src/pythonnative/hooks.py
@@ -83,8 +84,10 @@ tests/test_cli.py
 tests/test_components.py
 tests/test_element.py
 tests/test_hooks.py
+tests/test_ios_log.py
 tests/test_native_views.py
 tests/test_navigation.py
 tests/test_reconciler.py
 tests/test_smoke.py
-tests/test_style.py
+tests/test_style.py
+tests/test_utils.py

{pythonnative-0.8.0 → pythonnative-0.9.0}/tests/test_cli.py

@@ -41,6 +41,28 @@ def test_cli_init_and_clean() -> None:
         shutil.rmtree(tmpdir, ignore_errors=True)
 
 
+def test_cli_run_help_lists_logging_flags() -> None:
+    """`pn run --help` should advertise both --no-logs and --hot-reload."""
+    tmpdir = tempfile.mkdtemp(prefix="pn_cli_test_")
+    try:
+        result = run_pn(["run", "--help"], tmpdir)
+        assert result.returncode == 0, result.stderr
+        assert "--no-logs" in result.stdout
+        assert "--hot-reload" in result.stdout
+        assert "--prepare-only" in result.stdout
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+
+
+def test_cli_run_rejects_unknown_flag() -> None:
+    tmpdir = tempfile.mkdtemp(prefix="pn_cli_test_")
+    try:
+        result = run_pn(["run", "android", "--does-not-exist"], tmpdir)
+        assert result.returncode != 0
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+
+
 def test_cli_run_prepare_only_android_and_ios() -> None:
     tmpdir = tempfile.mkdtemp(prefix="pn_cli_test_")
     try:
@@ -48,8 +70,10 @@ def test_cli_run_prepare_only_android_and_ios() -> None:
         result = run_pn(["init", "MyApp"], tmpdir)
         assert result.returncode == 0, result.stderr
 
-        # prepare-only android
-        result = run_pn(["run", "android", "--prepare-only"], tmpdir)
+        # prepare-only android, combined with --no-logs to verify both flags
+        # coexist without launching any adb/simctl subprocess (prepare-only
+        # returns before logcat would ever be spawned).
+        result = run_pn(["run", "android", "--prepare-only", "--no-logs"], tmpdir)
         assert result.returncode == 0, result.stderr
         android_root = os.path.join(tmpdir, "build", "android", "android_template")
         assert os.path.isdir(android_root)
@@ -77,8 +101,8 @@ def test_cli_run_prepare_only_android_and_ios() -> None:
         )
         assert os.path.isfile(nav_graph)
 
-        # prepare-only ios
-        result = run_pn(["run", "ios", "--prepare-only"], tmpdir)
+        # prepare-only ios with --no-logs
+        result = run_pn(["run", "ios", "--prepare-only", "--no-logs"], tmpdir)
         assert result.returncode == 0, result.stderr
         assert os.path.isdir(os.path.join(tmpdir, "build", "ios", "ios_template"))
     finally:

pythonnative-0.9.0/tests/test_ios_log.py

@@ -0,0 +1,147 @@
+"""Tests for pythonnative._ios_log (iOS stdout/stderr redirection).
+
+These tests exercise the module's behavior directly without requiring
+an actual iOS runtime: ``_StderrStream`` writes via ``os.write(2, ...)``,
+and ``install()`` is idempotent and swaps the ``sys`` streams in place.
+"""
+
+import io
+import os
+import sys
+from typing import Generator, List, Tuple
+
+import pytest
+
+from pythonnative import _ios_log
+from pythonnative._ios_log import _StderrStream, install
+
+
+class TestStderrStream:
+    def test_write_sends_utf8_bytes_to_fd_2(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        captured: List[Tuple[int, bytes]] = []
+
+        def fake_write(fd: int, data: bytes) -> int:
+            captured.append((fd, data))
+            return len(data)
+
+        monkeypatch.setattr(os, "write", fake_write)
+
+        stream = _StderrStream()
+        written = stream.write("hello\n")
+
+        assert captured == [(2, b"hello\n")]
+        assert written == len(b"hello\n")
+
+    def test_write_handles_non_ascii(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        captured: List[bytes] = []
+
+        def fake_write(fd: int, data: bytes) -> int:
+            captured.append(data)
+            return len(data)
+
+        monkeypatch.setattr(os, "write", fake_write)
+
+        _StderrStream().write("héllo ✓\n")
+
+        assert captured == ["héllo ✓\n".encode("utf-8")]
+
+    def test_write_empty_string_is_no_op(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        calls: List[Tuple[int, bytes]] = []
+
+        def fake_write(fd: int, data: bytes) -> int:
+            calls.append((fd, data))
+            return len(data)
+
+        monkeypatch.setattr(os, "write", fake_write)
+
+        assert _StderrStream().write("") == 0
+        assert calls == []
+
+    def test_write_swallows_oserror(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        def boom(fd: int, data: bytes) -> int:
+            raise OSError("nope")
+
+        monkeypatch.setattr(os, "write", boom)
+
+        assert _StderrStream().write("x") == 0
+
+    def test_writelines_iterates(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        captured: List[bytes] = []
+
+        def fake_write(fd: int, data: bytes) -> int:
+            captured.append(data)
+            return len(data)
+
+        monkeypatch.setattr(os, "write", fake_write)
+
+        _StderrStream().writelines(["a\n", "b\n", "c\n"])
+
+        assert captured == [b"a\n", b"b\n", b"c\n"]
+
+    def test_stream_metadata(self) -> None:
+        stream = _StderrStream()
+        assert stream.encoding == "utf-8"
+        assert stream.errors == "replace"
+        assert stream.fileno() == 2
+        assert stream.closed is False
+        # flush() and close() are deliberate no-ops; just exercise them.
+        stream.flush()
+        stream.close()
+
+    def test_isatty_reflects_fd_2(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(os, "isatty", lambda fd: fd == 2)
+        assert _StderrStream().isatty() is True
+
+        def raiser(fd: int) -> bool:
+            raise OSError("bad fd")
+
+        monkeypatch.setattr(os, "isatty", raiser)
+        assert _StderrStream().isatty() is False
+
+
+class TestInstall:
+    @pytest.fixture(autouse=True)
+    def _reset_install_flag(self) -> Generator[None, None, None]:
+        """Ensure each test starts with a fresh, un-installed state."""
+        original_stdout = sys.stdout
+        original_stderr = sys.stderr
+        original_installed = _ios_log._installed
+        _ios_log._installed = False
+        try:
+            yield
+        finally:
+            sys.stdout = original_stdout
+            sys.stderr = original_stderr
+            _ios_log._installed = original_installed
+
+    def test_install_replaces_streams(self) -> None:
+        assert not isinstance(sys.stdout, _StderrStream)
+        assert not isinstance(sys.stderr, _StderrStream)
+
+        install()
+
+        assert isinstance(sys.stdout, _StderrStream)
+        assert isinstance(sys.stderr, _StderrStream)
+
+    def test_install_is_idempotent(self) -> None:
+        install()
+        first_stdout = sys.stdout
+        first_stderr = sys.stderr
+
+        install()
+        install()
+
+        # Second+ install() calls must be no-ops — the same objects remain.
+        assert sys.stdout is first_stdout
+        assert sys.stderr is first_stderr
+
+    def test_install_does_not_raise_when_streams_missing(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        # Replace stdout/stderr with something odd before install to confirm
+        # install() doesn't care about the prior stream.
+        monkeypatch.setattr(sys, "stdout", io.StringIO())
+        monkeypatch.setattr(sys, "stderr", io.StringIO())
+
+        install()
+
+        assert isinstance(sys.stdout, _StderrStream)
+        assert isinstance(sys.stderr, _StderrStream)

pythonnative-0.9.0/tests/test_utils.py

@@ -0,0 +1,70 @@
+"""Tests for pythonnative.utils platform detection."""
+
+import os
+import sys
+
+import pytest
+
+from pythonnative.utils import IS_ANDROID, IS_IOS, _detect_ios
+
+
+class TestIosDetection:
+    """``_detect_ios()`` should key off explicit signals only, not on the
+    presence of optional packages like ``rubicon-objc``.
+    """
+
+    def test_detects_via_pn_platform_env(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("PN_PLATFORM", "ios")
+        assert _detect_ios() is True
+
+    def test_other_pn_platform_values_ignored(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("PN_PLATFORM", "desktop")
+        monkeypatch.delenv("HOME", raising=False)
+        monkeypatch.setattr(sys, "platform", "darwin")
+        assert _detect_ios() is False
+
+    def test_detects_via_sys_platform_ios(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("PN_PLATFORM", raising=False)
+        monkeypatch.setattr(sys, "platform", "ios")
+        assert _detect_ios() is True
+
+    def test_detects_via_core_simulator_home(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("PN_PLATFORM", raising=False)
+        monkeypatch.setattr(sys, "platform", "darwin")
+        monkeypatch.setenv(
+            "HOME",
+            "/Users/x/Library/Developer/CoreSimulator/Devices/ABCD/data",
+        )
+        assert _detect_ios() is True
+
+    def test_plain_macos_is_not_ios(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("PN_PLATFORM", raising=False)
+        monkeypatch.setattr(sys, "platform", "darwin")
+        monkeypatch.setenv("HOME", "/Users/owen")
+        assert _detect_ios() is False
+
+    def test_plain_linux_is_not_ios(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("PN_PLATFORM", raising=False)
+        monkeypatch.setattr(sys, "platform", "linux")
+        monkeypatch.setenv("HOME", "/home/runner")
+        assert _detect_ios() is False
+
+
+class TestPlatformFlagsConsistency:
+    def test_both_flags_are_bools(self) -> None:
+        assert isinstance(IS_ANDROID, bool)
+        assert isinstance(IS_IOS, bool)
+
+    def test_flags_are_mutually_exclusive(self) -> None:
+        # A single Python process is never simultaneously Android and iOS.
+        assert not (IS_ANDROID and IS_IOS)
+
+    def test_ci_environment_is_neither(self) -> None:
+        """The test suite runs on Linux/macOS hosts, so both flags are False."""
+        # This is more of a smoke check of the import-time detection: if
+        # this ever starts being True on CI, someone has accidentally made
+        # platform detection overeager on non-device hosts.
+        if os.environ.get("PN_PLATFORM") == "ios":
+            pytest.skip("Running under PN_PLATFORM=ios; flags correctly reflect that.")
+        assert IS_ANDROID is False
+        assert IS_IOS is False