pythonnative 0.36.0__tar.gz → 0.37.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.36.0
+Version: 0.37.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License
@@ -44,8 +44,6 @@ 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 +76,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
 
@@ -94,7 +92,7 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 - **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.
 - **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.

{pythonnative-0.36.0 → pythonnative-0.37.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
 
@@ -42,7 +42,7 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 - **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.
 - **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.

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.36.0"
+version = "0.37.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }
@@ -30,9 +30,6 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-ios = [
-  "rubicon-objc>=0.4.6,<0.5.0",
-]
 build = [
   "Pillow>=10.0",
 ]
@@ -47,9 +44,10 @@ 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
-  # path. `uv sync` does not seed pip the way `uv venv --seed` did.
+  # `pn run ios` shells out to `sys.executable -m pip` to vendor the
+  # app's [requirements].packages (project/builder.py), and the test
+  # suite exercises that path. `uv sync` does not seed pip the way
+  # `uv venv --seed` did.
   "pip>=24.0",
 ]
 docs = [
@@ -92,6 +90,7 @@ license-files = ["LICENSE*"]
 # Include template directories inside the package so importlib.resources can find them
 [tool.setuptools.package-data]
 pythonnative = [
+  "py.typed",
   "templates/**",
 ]
 

{pythonnative-0.36.0 → pythonnative-0.37.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.37.0"
 
 from . import appearance, diagnostics, gestures, images, runtime, sdk
 from .alerts import Alert

{pythonnative-0.36.0 → pythonnative-0.37.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.37.0}/src/pythonnative/alerts.py

@@ -30,77 +30,42 @@ 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,
-        }
-    )
-    response = Alert._next_test_response()
-    on_result(response)
+    try:
+        result = await native_module("Alert").call_async(
+            "present", title=title, message=message, buttons=buttons, style=style
+        )
+    except Exception:
+        return -1
+    try:
+        return int(result)
+    except (TypeError, ValueError):
+        return -1
 
 
 # ======================================================================
@@ -170,13 +135,14 @@ 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,
-        )
+        try:
+            native_module("Alert").call(
+                "show", title=title, message=message, buttons=[{"label": button, "style": "default"}], style="alert"
+            )
+        except Exception:
+            from . import diagnostics
+
+            diagnostics.swallowed("alerts.Alert.show")
 
     @staticmethod
     async def confirm(
@@ -206,13 +172,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 +180,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 +224,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 +235,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.37.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)