pythonnative 0.36.0__tar.gz → 0.38.0__tar.gz

{pythonnative-0.36.0/src/pythonnative.egg-info → pythonnative-0.38.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.36.0
+Version: 0.38.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License
@@ -34,18 +34,13 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: User Interfaces
-Requires-Python: >=3.10
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.31.0
-Requires-Dist: tomli>=2.0; python_version < "3.11"
-Requires-Dist: typing_extensions>=4.4; python_version < "3.11"
-Provides-Extra: ios
-Requires-Dist: rubicon-objc<0.5.0,>=0.4.6; extra == "ios"
 Provides-Extra: build
 Requires-Dist: Pillow>=10.0; extra == "build"
 Dynamic: license-file
@@ -78,7 +73,7 @@ Dynamic: license-file
 
 ## Overview
 
-PythonNative is a cross-platform toolkit for building native Android and iOS apps in Python. It provides a **declarative, React-like component model** with hooks and automatic reconciliation, powered by Chaquopy on Android and rubicon-objc on iOS. Write function components with `use_state`, `use_effect`, and friends, just like React, and let PythonNative handle creating and updating native views.
+PythonNative is a cross-platform toolkit for building native Android and iOS apps in Python. It provides a **declarative, React-like component model** with hooks and automatic reconciliation on top of a **native rendering core** written in Swift and Kotlin. Write function components with `use_state`, `use_effect`, and friends, just like React, and let PythonNative handle creating and updating native views.
 
 ## Features
 
@@ -88,15 +83,16 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 - **Hooks and function components:** Manage state with `use_state`, side effects with `use_effect` / `use_layout_effect`, refs and imperative handles with `use_ref` / `use_imperative_handle`, and navigation with `use_navigation`, all through one consistent pattern. Components can return a single element, a list of siblings, or `None`, and `Fragment`, `Portal`, and reactive `Provider` context work the way they do in React.
 - **Async-first rendering:** One `asyncio` event loop runs the whole framework on the platform's main thread. Components can be `async def` and `await` data directly in the body; `Suspense` boundaries show declarative loading states while they wait. `use_resource` fetches during render, `use_effect` accepts coroutine callbacks (cancelled automatically on unmount), `lazy` code-splits components, and `use_transition` / `use_deferred_value` keep the UI responsive during expensive updates.
 - **Developer feedback that finds your bugs:** In dev mode (`pn preview`, hot reload, or `PN_DEV=1`), uncaught errors from renders, effects, and event handlers show a full-screen RedBox with the traceback; unknown style keys and duplicate list keys print "did you mean" warnings; and conditional hooks raise a `HookOrderError` at the source instead of silently cross-wiring state.
-- **Typed `style` prop:** Pass all visual and layout properties through a single `style` dict, fully described by the `pn.Style` `TypedDict` and the ergonomic `pn.style(...)` helper for IDE autocomplete and static checking. Compose reusable styles with `StyleSheet`.
+- **Typed `style` prop and theme:** Pass all visual and layout properties through a single `style` dict, fully described by the `pn.Style` `TypedDict` and the ergonomic `pn.style(...)` helper for IDE autocomplete and static checking. Compose reusable styles with `StyleSheet`, and read design tokens from a typed, immutable `pn.Theme` via `use_theme()` that follows light and dark mode by default.
 - **Cross-platform flexbox engine:** A pure-Python, Yoga-style layout engine computes frames once and applies them to native views, so `flex`, `padding`, `aspect_ratio`, and `position: "absolute"` produce the same geometry on Android and iOS.
 - **Virtual view tree + reconciler:** Element trees are diffed and patched with minimal native mutations, similar to React's reconciliation. Each commit lands as **one batched transaction** of mutation ops, and event callbacks are routed through a tag-based registry so re-renders that only change closures cost zero native calls. State updates re-render **locally**: only the component whose state changed (and its subtree) re-runs, and unchanged leaves reuse cached intrinsic measurements, so deep UIs stay responsive instead of re-rendering the whole app from the root on every tap.
 - **Native-driven animations:** The `Animated` API (timing / spring / decay / loop / stagger, awaitable or fire-and-forget) hands animations to Core Animation and `ViewPropertyAnimator` whenever possible, so no Python code runs per frame; a pure-Python ticker covers the rest. `interpolate`, arithmetic operators on animated nodes, `Animated.event` scroll binding, and `diff_clamp` cover the scroll-driven patterns (collapsing headers, parallax) that define native feel.
 - **Native gesture system:** Attach `Tap`, `LongPress`, `Pan`, `Swipe`, `Fling`, `Pinch`, and `Rotation` recognizers to any view via the `gestures=` prop, backed by `UIGestureRecognizer` on iOS and a unit-testable pure-Python arbiter on Android and desktop. Compose them with `Race`, `Exclusive`, and `Simultaneous` for cross-gesture arbitration (single vs. double tap, drag vs. long press).
 - **Virtualized lists:** `FlatList` / `SectionList` window their rows in Python over the platform scroll view: uniform, exact, or measured variable heights, grids, headers/footers, infinite scroll, and an imperative scroll controller, identical on every platform.
-- **Direct native bindings:** Python calls platform APIs directly through Chaquopy and rubicon-objc, with no JavaScript bridge.
+- **Native rendering core:** each commit is one serialized transaction applied by Swift and Kotlin component managers, the same shape as React Native's Fabric. Device APIs are native modules registered by name (TurboModules-style), callable from thin Python facades.
 - **Custom-component SDK:** Wrap any platform widget as a first-class element with type-checked props via `pythonnative.sdk` (`Props`, `@native_component`, `element_factory`). Plugins distributed on PyPI auto-register through the `pythonnative.handlers` entry-point group.
 - **CLI scaffolding:** `pn init` creates a ready-to-run project; `pn run android` and `pn run ios` build and launch your app.
+- **PyPI packages, binary wheels included:** List requirements in `pythonnative.toml` and the CLI resolves them for the *device* (iOS wheels via PEP 730 and BeeWare's index, Android wheels via PEP 738 and Chaquopy), bundling numpy, Pillow, cryptography, and friends alongside pure-Python packages. `pn deps` reports what each target resolves to before you build, and a weekly-checked compatibility matrix keeps the docs honest.
 - **Instant desktop preview:** `pn preview` renders your app in a native desktop window via Tkinter with Fast Refresh on every save: iterate on layout, state, and navigation in milliseconds without booting a simulator or device. The reconciler, hooks, layout engine, and navigation are the same code that ships to the phone.
 - **Native-backed navigation:** Declarative `Stack`, `Tab`, and `Drawer` navigators inspired by React Navigation. The root stack drives the platform's native navigation controller (`UINavigationController` on iOS, AndroidX Navigation Component on Android), so transitions, back gestures, and the hardware back button match what users expect; `use_back_handler` intercepts the back action when a screen needs to.
 - **Fast Refresh hot reload:** `pn run --hot-reload` watches `app/` and patches edits into the running app on save, preserving component state across most changes.
@@ -106,6 +102,8 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 
 ### Installation
 
+Requires Python 3.13 or newer.
+
 ```bash
 pip install pythonnative
 ```

{pythonnative-0.36.0 → pythonnative-0.38.0}/README.md

@@ -26,7 +26,7 @@
 
 ## Overview
 
-PythonNative is a cross-platform toolkit for building native Android and iOS apps in Python. It provides a **declarative, React-like component model** with hooks and automatic reconciliation, powered by Chaquopy on Android and rubicon-objc on iOS. Write function components with `use_state`, `use_effect`, and friends, just like React, and let PythonNative handle creating and updating native views.
+PythonNative is a cross-platform toolkit for building native Android and iOS apps in Python. It provides a **declarative, React-like component model** with hooks and automatic reconciliation on top of a **native rendering core** written in Swift and Kotlin. Write function components with `use_state`, `use_effect`, and friends, just like React, and let PythonNative handle creating and updating native views.
 
 ## Features
 
@@ -36,15 +36,16 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 - **Hooks and function components:** Manage state with `use_state`, side effects with `use_effect` / `use_layout_effect`, refs and imperative handles with `use_ref` / `use_imperative_handle`, and navigation with `use_navigation`, all through one consistent pattern. Components can return a single element, a list of siblings, or `None`, and `Fragment`, `Portal`, and reactive `Provider` context work the way they do in React.
 - **Async-first rendering:** One `asyncio` event loop runs the whole framework on the platform's main thread. Components can be `async def` and `await` data directly in the body; `Suspense` boundaries show declarative loading states while they wait. `use_resource` fetches during render, `use_effect` accepts coroutine callbacks (cancelled automatically on unmount), `lazy` code-splits components, and `use_transition` / `use_deferred_value` keep the UI responsive during expensive updates.
 - **Developer feedback that finds your bugs:** In dev mode (`pn preview`, hot reload, or `PN_DEV=1`), uncaught errors from renders, effects, and event handlers show a full-screen RedBox with the traceback; unknown style keys and duplicate list keys print "did you mean" warnings; and conditional hooks raise a `HookOrderError` at the source instead of silently cross-wiring state.
-- **Typed `style` prop:** Pass all visual and layout properties through a single `style` dict, fully described by the `pn.Style` `TypedDict` and the ergonomic `pn.style(...)` helper for IDE autocomplete and static checking. Compose reusable styles with `StyleSheet`.
+- **Typed `style` prop and theme:** Pass all visual and layout properties through a single `style` dict, fully described by the `pn.Style` `TypedDict` and the ergonomic `pn.style(...)` helper for IDE autocomplete and static checking. Compose reusable styles with `StyleSheet`, and read design tokens from a typed, immutable `pn.Theme` via `use_theme()` that follows light and dark mode by default.
 - **Cross-platform flexbox engine:** A pure-Python, Yoga-style layout engine computes frames once and applies them to native views, so `flex`, `padding`, `aspect_ratio`, and `position: "absolute"` produce the same geometry on Android and iOS.
 - **Virtual view tree + reconciler:** Element trees are diffed and patched with minimal native mutations, similar to React's reconciliation. Each commit lands as **one batched transaction** of mutation ops, and event callbacks are routed through a tag-based registry so re-renders that only change closures cost zero native calls. State updates re-render **locally**: only the component whose state changed (and its subtree) re-runs, and unchanged leaves reuse cached intrinsic measurements, so deep UIs stay responsive instead of re-rendering the whole app from the root on every tap.
 - **Native-driven animations:** The `Animated` API (timing / spring / decay / loop / stagger, awaitable or fire-and-forget) hands animations to Core Animation and `ViewPropertyAnimator` whenever possible, so no Python code runs per frame; a pure-Python ticker covers the rest. `interpolate`, arithmetic operators on animated nodes, `Animated.event` scroll binding, and `diff_clamp` cover the scroll-driven patterns (collapsing headers, parallax) that define native feel.
 - **Native gesture system:** Attach `Tap`, `LongPress`, `Pan`, `Swipe`, `Fling`, `Pinch`, and `Rotation` recognizers to any view via the `gestures=` prop, backed by `UIGestureRecognizer` on iOS and a unit-testable pure-Python arbiter on Android and desktop. Compose them with `Race`, `Exclusive`, and `Simultaneous` for cross-gesture arbitration (single vs. double tap, drag vs. long press).
 - **Virtualized lists:** `FlatList` / `SectionList` window their rows in Python over the platform scroll view: uniform, exact, or measured variable heights, grids, headers/footers, infinite scroll, and an imperative scroll controller, identical on every platform.
-- **Direct native bindings:** Python calls platform APIs directly through Chaquopy and rubicon-objc, with no JavaScript bridge.
+- **Native rendering core:** each commit is one serialized transaction applied by Swift and Kotlin component managers, the same shape as React Native's Fabric. Device APIs are native modules registered by name (TurboModules-style), callable from thin Python facades.
 - **Custom-component SDK:** Wrap any platform widget as a first-class element with type-checked props via `pythonnative.sdk` (`Props`, `@native_component`, `element_factory`). Plugins distributed on PyPI auto-register through the `pythonnative.handlers` entry-point group.
 - **CLI scaffolding:** `pn init` creates a ready-to-run project; `pn run android` and `pn run ios` build and launch your app.
+- **PyPI packages, binary wheels included:** List requirements in `pythonnative.toml` and the CLI resolves them for the *device* (iOS wheels via PEP 730 and BeeWare's index, Android wheels via PEP 738 and Chaquopy), bundling numpy, Pillow, cryptography, and friends alongside pure-Python packages. `pn deps` reports what each target resolves to before you build, and a weekly-checked compatibility matrix keeps the docs honest.
 - **Instant desktop preview:** `pn preview` renders your app in a native desktop window via Tkinter with Fast Refresh on every save: iterate on layout, state, and navigation in milliseconds without booting a simulator or device. The reconciler, hooks, layout engine, and navigation are the same code that ships to the phone.
 - **Native-backed navigation:** Declarative `Stack`, `Tab`, and `Drawer` navigators inspired by React Navigation. The root stack drives the platform's native navigation controller (`UINavigationController` on iOS, AndroidX Navigation Component on Android), so transitions, back gestures, and the hardware back button match what users expect; `use_back_handler` intercepts the back action when a screen needs to.
 - **Fast Refresh hot reload:** `pn run --hot-reload` watches `app/` and patches edits into the running app on save, preserving component state across most changes.
@@ -54,6 +55,8 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 
 ### Installation
 
+Requires Python 3.13 or newer.
+
 ```bash
 pip install pythonnative
 ```

{pythonnative-0.36.0 → pythonnative-0.38.0}/pyproject.toml

@@ -4,13 +4,17 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.36.0"
+version = "0.38.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }
 ]
 readme = "README.md"
-requires-python = ">=3.10"
+# The host interpreter must match the embedded runtime (app.python_version)
+# for device builds, and the embedded runtimes are 3.13 and 3.14: CPython
+# gained official iOS support (PEP 730) and Android support (PEP 738) in
+# 3.13, which is what makes binary wheels from PyPI installable at all.
+requires-python = ">=3.13"
 license = { file = "LICENSE" }
 classifiers = [
   "Development Status :: 2 - Pre-Alpha",
@@ -18,21 +22,15 @@ classifiers = [
   "License :: OSI Approved :: MIT License",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.10",
-  "Programming Language :: Python :: 3.11",
-  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Topic :: Software Development :: User Interfaces",
 ]
 dependencies = [
   "requests>=2.31.0",
-  "tomli>=2.0; python_version < '3.11'",
-  "typing_extensions>=4.4; python_version < '3.11'",
 ]
 
 [project.optional-dependencies]
-ios = [
-  "rubicon-objc>=0.4.6,<0.5.0",
-]
 build = [
   "Pillow>=10.0",
 ]
@@ -47,8 +45,9 @@ dev = [
   "pytest>=8.0",
   "pytest-asyncio>=0.23",
   "Pillow>=10.0",
-  # `pn run ios` shells out to `sys.executable -m pip` to vendor
-  # rubicon-objc (project/builder.py), and the test suite exercises that
+  # `pn deps` and `pn run ios` shell out to `sys.executable -m pip` to
+  # resolve and vendor the app's [requirements].packages for the device
+  # platform tags (project/deps.py), and the test suite exercises that
   # path. `uv sync` does not seed pip the way `uv venv --seed` did.
   "pip>=24.0",
 ]
@@ -92,11 +91,12 @@ license-files = ["LICENSE*"]
 # Include template directories inside the package so importlib.resources can find them
 [tool.setuptools.package-data]
 pythonnative = [
+  "py.typed",
   "templates/**",
 ]
 
 [tool.ruff]
-target-version = "py39"
+target-version = "py313"
 line-length = 120
 extend-exclude = [
   "templates",
@@ -137,10 +137,7 @@ convention = "google"
 
 [tool.black]
 line-length = 120
-target-version = ['py39']
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
+target-version = ['py313']
 
 # ── Semantic Release ────────────────────────────────────────────────
 

{pythonnative-0.36.0 → pythonnative-0.38.0}/src/pythonnative/__init__.py

@@ -2,9 +2,11 @@
 
 PythonNative is a cross-platform toolkit that turns Python ``@component``
 functions into real, native Android and iOS views. The component model
-is React-like (function components plus hooks), but rendering happens
-through direct platform bindings: Chaquopy on Android (Java) and
-rubicon-objc on iOS (Objective-C). There is no JavaScript bridge.
+is React-like (function components plus hooks). Python owns the
+component tree, reconciliation, and layout; each commit crosses once
+into a native rendering core (Swift ``PythonNativeKit`` on iOS, the
+Kotlin ``pythonnative`` module on Android) that owns every platform
+view, gesture, animation, and device API. There is no JavaScript.
 
 Key building blocks:
 
@@ -60,7 +62,7 @@ Example:
     ```
 """
 
-__version__ = "0.36.0"
+__version__ = "0.38.0"
 
 from . import appearance, diagnostics, gestures, images, runtime, sdk
 from .alerts import Alert
@@ -188,6 +190,7 @@ from .style import (
     AutoCapitalize,
     Color,
     Dimension,
+    Display,
     EdgeInsets,
     FlexDirection,
     FlexWrap,
@@ -196,6 +199,7 @@ from .style import (
     KeyboardType,
     LayoutDirection,
     Overflow,
+    PointerEvents,
     Position,
     ReturnKeyType,
     ScaleType,
@@ -205,6 +209,8 @@ from .style import (
     StyleSheet,
     TextAlign,
     TextDecoration,
+    TextTransform,
+    Theme,
     ThemeContext,
     TransformSpec,
     default_theme,
@@ -312,6 +318,7 @@ __all__ = [
     "DEFAULT_DARK_THEME",
     "DEFAULT_LIGHT_THEME",
     "Dimension",
+    "Display",
     "EdgeInsets",
     "FlexDirection",
     "FlexWrap",
@@ -320,6 +327,7 @@ __all__ = [
     "KeyboardType",
     "LayoutDirection",
     "Overflow",
+    "PointerEvents",
     "Position",
     "ReturnKeyType",
     "ScaleType",
@@ -329,6 +337,8 @@ __all__ = [
     "StyleSheet",
     "TextAlign",
     "TextDecoration",
+    "TextTransform",
+    "Theme",
     "ThemeContext",
     "TransformSpec",
     "default_theme",

{pythonnative-0.36.0 → pythonnative-0.38.0}/src/pythonnative/_ios_log.py

@@ -14,7 +14,7 @@ straight to fd 2 is a small, reliable fix: fd 2 *is* visible to
 `simctl` (that is 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
+This module is intentionally self-contained (no bridge or
 platform-specific C bindings required), so it is safe to import
 early during `pythonnative` package initialization.
 """

{pythonnative-0.36.0 → pythonnative-0.38.0}/src/pythonnative/alerts.py

@@ -30,77 +30,39 @@ Example:
 
 from __future__ import annotations
 
-import asyncio
 from typing import Any, Dict, List, Optional, Sequence
 
-from .platform import Platform
-from .runtime import resolve_future
+from .native_modules.registry import native_module
 
 # ======================================================================
 # Internal dispatch helpers
 # ======================================================================
 
 
-def _dispatch_alert(
+async def _present(
     *,
     title: str,
     message: Optional[str],
     buttons: List[Dict[str, Any]],
     style: str,
-    on_result: Any,
-) -> None:
-    """Route an alert request to the active platform presenter.
+) -> int:
+    """Ask the native ``Alert`` module to present and await the chosen index.
 
     ``buttons`` is a list of ``{"label": str, "style":
-    "default"|"cancel"|"destructive"}`` dicts. The presenter must
-    invoke ``on_result(index)`` exactly once when the user picks a
-    button, or ``on_result(-1)`` if the dialog is dismissed without a
-    selection. ``on_result`` may run on any thread.
+    "default"|"cancel"|"destructive"}`` dicts. The module resolves with
+    the index the user picked, or ``-1`` if the dialog was dismissed
+    without a selection. Off device the
+    [`DesktopAlert`][pythonnative.native_modules.desktop.DesktopAlert]
+    implementation records the call and answers from the queue set by
+    [`Alert.set_test_response`][pythonnative.alerts.Alert.set_test_response].
     """
-    if Platform.is_ios:
-        try:
-            from .native_views.ios import _present_alert as _ios_present_alert
-
-            _ios_present_alert(
-                title=title,
-                message=message,
-                buttons=buttons,
-                style=style,
-                on_result=on_result,
-            )
-            return
-        except Exception:
-            on_result(-1)
-            return
-
-    if Platform.is_android:
-        try:
-            from .native_views.android import _present_alert as _android_present_alert
-
-            _android_present_alert(
-                title=title,
-                message=message,
-                buttons=buttons,
-                style=style,
-                on_result=on_result,
-            )
-            return
-        except Exception:
-            on_result(-1)
-            return
-
-    # Test backend: record the call so unit tests can assert on it,
-    # then deliver the configured response.
-    Alert._test_log.append(
-        {
-            "title": title,
-            "message": message,
-            "buttons": list(buttons),
-            "style": style,
-        }
+    result = await native_module("Alert").call_async(
+        "present", title=title, message=message, buttons=buttons, style=style
     )
-    response = Alert._next_test_response()
-    on_result(response)
+    try:
+        return int(result)
+    except (TypeError, ValueError):
+        return -1
 
 
 # ======================================================================
@@ -170,12 +132,8 @@ class Alert:
         [`choose`][pythonnative.alerts.Alert.choose] and ``await``
         the result.
         """
-        _dispatch_alert(
-            title=title,
-            message=message,
-            buttons=[{"label": button, "style": "default"}],
-            style="alert",
-            on_result=lambda _idx: None,
+        native_module("Alert").call(
+            "show", title=title, message=message, buttons=[{"label": button, "style": "default"}], style="alert"
         )
 
     @staticmethod
@@ -206,13 +164,7 @@ class Alert:
                 await save()
             ```
         """
-        loop = asyncio.get_running_loop()
-        future: asyncio.Future[bool] = loop.create_future()
-
-        def _on_result(index: int) -> None:
-            resolve_future(future, index == 1)
-
-        _dispatch_alert(
+        index = await _present(
             title=title,
             message=message,
             buttons=[
@@ -220,9 +172,8 @@ class Alert:
                 {"label": confirm_label, "style": "default"},
             ],
             style="alert",
-            on_result=_on_result,
         )
-        return await future
+        return index == 1
 
     @staticmethod
     async def choose(
@@ -265,9 +216,6 @@ class Alert:
         if not options:
             raise ValueError("Alert.choose requires at least one option")
 
-        loop = asyncio.get_running_loop()
-        future: asyncio.Future[Optional[str]] = loop.create_future()
-
         destructive = set(destructive_labels)
         buttons: List[Dict[str, Any]] = [
             {
@@ -279,20 +227,10 @@ class Alert:
         if cancel_label is not None:
             buttons.append({"label": cancel_label, "style": "cancel"})
 
-        def _on_result(index: int) -> None:
-            if 0 <= index < len(options):
-                resolve_future(future, options[index])
-            else:
-                resolve_future(future, None)
-
-        _dispatch_alert(
-            title=title,
-            message=message,
-            buttons=buttons,
-            style=style,
-            on_result=_on_result,
-        )
-        return await future
+        index = await _present(title=title, message=message, buttons=buttons, style=style)
+        if 0 <= index < len(options):
+            return options[index]
+        return None
 
 
 __all__ = ["Alert"]

pythonnative-0.38.0/src/pythonnative/bootstrap.py

@@ -0,0 +1,90 @@
+"""Entry point the native app templates run right after Python starts.
+
+Both templates execute one line of Python once the interpreter is up:
+
+```python
+import pythonnative.bootstrap; pythonnative.bootstrap.start()
+```
+
+[`start`][pythonnative.bootstrap.start] connects the two halves of the
+bridge (installing the native -> Python callback on iOS), verifies the
+protocol version, routes ``print()`` to the console on iOS, and warms
+the asyncio runtime. From then on the native runtime drives everything
+through ``callback("host", ...)``; see ``docs/concepts/bridge.md``.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import traceback
+from typing import Any, Dict
+
+__all__ = ["start", "status"]
+
+_started: Dict[str, Any] = {}
+
+
+def start(dev: bool = False, strict: bool = False) -> Dict[str, Any]:
+    """Connect the bridge and prepare the runtime.
+
+    Args:
+        dev: Enable dev mode (RedBox, validation warnings). Debug
+            templates pass ``True``; hot reload turns it on as well.
+        strict: Re-raise the failure after recording it. The templates
+            pass ``True`` so a broken bridge surfaces as a bootstrap
+            error screen with the full traceback.
+
+    Returns:
+        A status dict (``{"protocol": 1, "platform": "ios"}``) that the
+        template logs. Unless ``strict`` is set this never raises:
+        failures are printed and reported in the dict under
+        ``"error"``.
+    """
+    global _started
+    if _started and "error" not in _started:
+        return dict(_started)
+    status_: Dict[str, Any] = {"platform": None, "protocol": None}
+    try:
+        from .utils import IS_ANDROID, IS_IOS
+
+        status_["platform"] = "ios" if IS_IOS else "android" if IS_ANDROID else "off-device"
+        if IS_IOS:
+            try:
+                from . import _ios_log
+
+                _ios_log.install()
+            except Exception:
+                pass
+        from . import bridge
+
+        status_["protocol"] = bridge.handshake()
+        if dev or os.environ.get("PN_DEV") in ("1", "true"):
+            from . import diagnostics
+
+            diagnostics.set_dev_mode(True)
+        # Create the guest loop now so the first pump request has a
+        # loop to drive and effects can schedule work during mount.
+        from .runtime import get_loop
+
+        get_loop()
+        # Import the view backend eagerly: on a slow device the first
+        # commit shouldn't also pay for importing the reconciler.
+        from .native_views import get_registry
+
+        get_registry()
+    except Exception as exc:
+        status_["error"] = f"{type(exc).__name__}: {exc}"
+        print(f"[pn.bootstrap] start failed: {exc!r}", file=sys.stderr)
+        traceback.print_exc()
+        _started = status_
+        if strict:
+            raise
+        return dict(status_)
+    _started = status_
+    return dict(status_)
+
+
+def status() -> Dict[str, Any]:
+    """Return the result of the last [`start`][pythonnative.bootstrap.start] (empty before it ran)."""
+    return dict(_started)