pythonnative 0.38.0__tar.gz → 0.40.0__tar.gz

pythonnative-0.40.0/MANIFEST.in

@@ -0,0 +1,11 @@
+global-exclude *.pyc *.pyo .DS_Store
+recursive-exclude src/pythonnative/native .build/* .gradle/* .cxx/* build/* .swiftpm/* .kotlin/*
+prune src/pythonnative/native/android/build
+prune src/pythonnative/native/android/.gradle
+prune src/pythonnative/native/android/.cxx
+prune src/pythonnative/native/ios/.build
+prune src/pythonnative/native/ios/.swiftpm
+prune src/pythonnative/native/yoga/.build
+prune src/pythonnative/templates/android_template/app/build
+prune src/pythonnative/templates/android_template/.gradle
+prune src/pythonnative/templates/ios_template/build

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.38.0
+Version: 0.40.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License
@@ -82,20 +82,20 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 - **Device APIs:** Cross-platform modules for `Camera`, `Location`, `FileSystem`, `Notifications`, `Clipboard`, `Share`, `Linking`, `Permissions`, `AppState`, `NetInfo`, `SecureStore`, `Battery`, `Haptics` / `Vibration`, and `Biometrics`, plus reactive `use_app_state` and `use_net_info` hooks.
 - **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.
+- **Developer feedback that finds your bugs:** In dev mode (`pn start`, `pn preview`, debug builds from `pn run`, 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 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).
+- **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 in the browser preview. 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.
 - **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.
+- **Metro-style dev loop:** `pn start` runs one dev server that serves the browser preview and every connected debug build. Save a file and each client Fast Refreshes in place, keeping component state; their `print` output and tracebacks stream back into the same terminal. `pn run android` / `pn run ios` bakes the server URL into a debug build and rebuilds the native project only when a native input actually changed, so relaunching after a Python edit takes seconds, not minutes.
 - **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.
+- **Browser preview:** `pn preview` renders your app in a browser tab inside a phone frame (pick a device, rotate, toggle dark mode) with Fast Refresh on every save. The page is a bridge peer exactly like the Swift and Kotlin runtimes, so the reconciler, hooks, layout engine, navigation, and screen host are the same code that ships to the phone; only the leaf widgets are DOM elements.
 - **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.
+- **Dev client:** Build a shell app once with `pn run ios --dev-client` and point it at any project's dev server from a connect screen, the way Expo Go does; physical phones on the same Wi-Fi get the same Fast Refresh as simulators.
 - **Bundled templates:** Android Gradle and iOS Xcode templates are included, so scaffolding requires no network access.
 
 ## Quick Start
@@ -127,6 +127,16 @@ def App():
     )
 ```
 
+### Develop
+
+```bash
+pn init my-app && cd my-app
+pn preview          # dev server + browser preview with Fast Refresh
+pn run ios          # in another terminal: debug build that connects to the same server
+pn run android
+pn build ios        # standalone release artifacts
+```
+
 ## Documentation
 
 Visit [pythonnative.com](https://pythonnative.com/) for the full documentation, including getting started guides, platform-specific instructions for Android and iOS, API reference, and working examples.

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

@@ -35,20 +35,20 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 - **Device APIs:** Cross-platform modules for `Camera`, `Location`, `FileSystem`, `Notifications`, `Clipboard`, `Share`, `Linking`, `Permissions`, `AppState`, `NetInfo`, `SecureStore`, `Battery`, `Haptics` / `Vibration`, and `Biometrics`, plus reactive `use_app_state` and `use_net_info` hooks.
 - **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.
+- **Developer feedback that finds your bugs:** In dev mode (`pn start`, `pn preview`, debug builds from `pn run`, 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 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).
+- **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 in the browser preview. 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.
 - **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.
+- **Metro-style dev loop:** `pn start` runs one dev server that serves the browser preview and every connected debug build. Save a file and each client Fast Refreshes in place, keeping component state; their `print` output and tracebacks stream back into the same terminal. `pn run android` / `pn run ios` bakes the server URL into a debug build and rebuilds the native project only when a native input actually changed, so relaunching after a Python edit takes seconds, not minutes.
 - **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.
+- **Browser preview:** `pn preview` renders your app in a browser tab inside a phone frame (pick a device, rotate, toggle dark mode) with Fast Refresh on every save. The page is a bridge peer exactly like the Swift and Kotlin runtimes, so the reconciler, hooks, layout engine, navigation, and screen host are the same code that ships to the phone; only the leaf widgets are DOM elements.
 - **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.
+- **Dev client:** Build a shell app once with `pn run ios --dev-client` and point it at any project's dev server from a connect screen, the way Expo Go does; physical phones on the same Wi-Fi get the same Fast Refresh as simulators.
 - **Bundled templates:** Android Gradle and iOS Xcode templates are included, so scaffolding requires no network access.
 
 ## Quick Start
@@ -80,6 +80,16 @@ def App():
     )
 ```
 
+### Develop
+
+```bash
+pn init my-app && cd my-app
+pn preview          # dev server + browser preview with Fast Refresh
+pn run ios          # in another terminal: debug build that connects to the same server
+pn run android
+pn build ios        # standalone release artifacts
+```
+
 ## Documentation
 
 Visit [pythonnative.com](https://pythonnative.com/) for the full documentation, including getting started guides, platform-specific instructions for Android and iOS, API reference, and working examples.

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.38.0"
+version = "0.40.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }
@@ -88,11 +88,20 @@ where = ["src"]
 [tool.setuptools]
 license-files = ["LICENSE*"]
 
-# Include template directories inside the package so importlib.resources can find them
+# Include template directories and the browser preview's page assets inside
+# the package so importlib.resources can find them
 [tool.setuptools.package-data]
 pythonnative = [
   "py.typed",
-  "templates/**",
+  "templates/**", "native/**", "sdk/templates/**",
+  "devserver/static/**",
+]
+
+[tool.setuptools.exclude-package-data]
+pythonnative = [
+  "**/build/**", "**/.build/**", "**/.gradle/**",
+  "**/.cxx/**", "**/.swiftpm/**", "**/.kotlin/**",
+  "**/__pycache__/**", "**/.DS_Store",
 ]
 
 [tool.ruff]
@@ -127,7 +136,6 @@ ignore = ["D107", "D105", "D203", "D213"]
 # docstrings would only add boilerplate that repeats the ABC.
 "src/pythonnative/native_views/android.py" = ["D101", "D102"]
 "src/pythonnative/native_views/ios.py" = ["D101", "D102"]
-"src/pythonnative/native_views/desktop.py" = ["D101", "D102"]
 # ios.py embeds a LaunchScreen storyboard as an XML string literal whose
 # lines exceed the limit; the XML must stay on single lines for Xcode.
 "src/pythonnative/project/ios.py" = ["E501"]

pythonnative-0.40.0/setup.py

@@ -0,0 +1,19 @@
+"""Build the host Yoga binding; mobile hosts compile the vendored core."""
+
+import os
+from pathlib import Path
+
+from setuptools import Extension, setup
+
+root = Path("src/pythonnative/native/yoga")
+setup(
+    ext_modules=[
+        Extension(
+            "pythonnative._yoga",
+            sources=[str(root / "python.cpp"), *map(str, sorted((root / "yoga").rglob("*.cpp")))],
+            include_dirs=[str(root)],
+            language="c++",
+            extra_compile_args=["/std:c++20"] if os.name == "nt" else ["-std=c++20"],
+        )
+    ]
+)

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

@@ -62,9 +62,9 @@ Example:
     ```
 """
 
-__version__ = "0.38.0"
+__version__ = "0.40.0"
 
-from . import appearance, diagnostics, gestures, images, runtime, sdk
+from . import appearance, diagnostics, gestures, runtime, sdk
 from .alerts import Alert
 from .animated import Animated, AnimatedValue, use_animated_value
 from .component import Component, component, memo
@@ -348,7 +348,6 @@ __all__ = [
     # Appearance
     "appearance",
     # Image pipeline
-    "images",
     # Animation
     "Animated",
     "AnimatedValue",

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

@@ -52,7 +52,7 @@ async def _present(
     "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]
+    [`FallbackAlert`][pythonnative.native_modules.fallback.FallbackAlert]
     implementation records the call and answers from the queue set by
     [`Alert.set_test_response`][pythonnative.alerts.Alert.set_test_response].
     """

{pythonnative-0.38.0 → pythonnative-0.40.0}/src/pythonnative/animated.py

@@ -40,7 +40,7 @@ native view the value is attached to
   callback when the animation settles, updates the
   [`AnimatedValue`][pythonnative.animated.AnimatedValue], and resolves
   any awaiting tasks.
-- **Declined** (desktop preview, unattached values, callable easings,
+- **Declined** (unattached values, callable easings,
   values feeding Python-side listeners or derived nodes): a single
   background thread ticks the animation at ~60 Hz from Python, pushing
   each frame through ``set_animated_property``. Semantics are
@@ -85,7 +85,7 @@ import weakref
 from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
 
 from .element import Element
-from .hooks import use_effect, use_ref
+from .hooks import Ref, use_effect, use_ref
 from .runtime import resolve_future
 from .style import StyleProp, resolve_style
 
@@ -243,12 +243,17 @@ class AnimatedNode:
         except Exception:
             pass
 
+        from .animation_graph import install
+
+        install(self)
+
         def _detach() -> None:
             with self._lock:
                 try:
                     self._attachments.remove(binding)
                 except ValueError:
                     pass
+            install(self, detached_tag=tag)
 
         return _detach
 
@@ -404,6 +409,12 @@ class AnimatedValue(AnimatedNode):
     def set_value(self, new_value: float) -> None:
         """Set the value immediately, pushing to native views and listeners."""
         self._apply(float(new_value), push_native=True)
+        from .animation_graph import install
+
+        graph = install(self)
+        if graph and graph["bindings"]:
+            backend = _backend()
+            backend.set_animated_property(graph["bindings"][0][0], f"_pn_graph:{id(self)}", float(new_value))
 
     def _apply(self, new_value: float, push_native: bool) -> None:
         with self._lock:
@@ -695,7 +706,12 @@ class AnimatedEvent:
             if raw is None:
                 continue
             try:
-                node.set_value(float(raw))
+                if getattr(_backend(), "install_animation_graph", None) is not None:
+                    # Native already evaluated the graph at the input timestamp.
+                    # Python observes the sample without echoing an older frame.
+                    node._value = float(raw)
+                else:
+                    node.set_value(float(raw))
             except (TypeError, ValueError):
                 continue
         if self._listener is not None:
@@ -1041,21 +1057,21 @@ def _start_native(value: AnimatedValue, spec: Dict[str, Any]) -> Optional[_Nativ
     animation; otherwise rolls back any accepted targets and returns
     ``None`` so the caller falls back to the Python ticker.
     """
-    targets = value.attachments()
-    if not targets:
-        return None
-    if value.has_listeners():
-        # Python listeners want per-frame values; only the ticker
-        # provides those.
-        return None
-    if value._has_dependents():
-        # Derived nodes (interpolations, arithmetic) need per-frame
-        # Python evaluation to keep their own attachments in sync.
-        return None
     try:
         backend = _backend()
     except Exception:
         return None
+    from .animation_graph import install
+
+    graph = install(value)
+    if graph and graph["bindings"]:
+        targets = [(graph["bindings"][0][0], f"_pn_graph:{id(value)}")]
+    else:
+        targets = value.attachments()
+        if value._has_dependents():
+            return None
+    if not targets or value.has_listeners():
+        return None
 
     group = _NativeAnimationGroup(value, _projected_final_value(spec))
     accepted: List[Tuple[int, int]] = []  # (anim_id, tag)
@@ -1368,24 +1384,32 @@ def _make_animated_factory(
         plain_style, bindings = _resolve_style_with_values(style)
 
         ref = use_ref(None)
+        attached: Ref[List[Callable[[], None]]] = use_ref([])
 
-        def _attach_bindings() -> Callable[[], None]:
+        def _attach_bindings() -> None:
             tag = ref._pn_tag
             if tag is None:
-                return lambda: None
+                return
+            # Derived nodes can be rebuilt on every render. Install their new
+            # bindings before releasing the old ones so a running native graph
+            # never temporarily loses every owner.
             detachers = [value.attach(tag, _animated_prop_name(prop)) for prop, value in bindings.items()]
+            previous = attached.current
+            attached.current = detachers
+            for detach in previous:
+                detach()
 
+        def _unmount_bindings() -> Callable[[], None]:
             def _cleanup() -> None:
-                for fn in detachers:
-                    try:
-                        fn()
-                    except Exception:
-                        pass
+                for detach in attached.current:
+                    detach()
+                attached.current = []
 
             return _cleanup
 
         # Re-attach whenever the binding set changes identity.
         use_effect(_attach_bindings, [tuple(sorted((k, id(v)) for k, v in bindings.items()))])
+        use_effect(_unmount_bindings, [])
 
         if element_type == "Text":
             text = children[0] if children else kwargs.pop("text", "")

pythonnative-0.40.0/src/pythonnative/animation_graph.py

@@ -0,0 +1,78 @@
+"""Portable animation expressions evaluated by the native UI thread."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def serialize(root: Any) -> dict[str, Any]:
+    """Serialize one connected animation graph in dependency order."""
+    from .animated import AnimatedInterpolation, AnimatedNode, AnimatedValue, _AnimatedDiffClamp, _AnimatedOperation
+
+    connected: dict[int, Any] = {}
+
+    def discover(node: Any) -> None:
+        if not isinstance(node, AnimatedNode) or id(node) in connected:
+            return
+        connected[id(node)] = node
+        for child in list(node._children):
+            discover(child)
+        for parent in getattr(node, "_parents", [getattr(node, "_parent", None)]):
+            discover(parent)
+
+    discover(root)
+    encoded: dict[int, dict[str, Any]] = {}
+
+    def encode(node: Any) -> Any:
+        if not isinstance(node, AnimatedNode):
+            return {"constant": float(node)}
+        identity = id(node)
+        if identity not in encoded:
+            definition: dict[str, Any] = {"id": identity}
+            if isinstance(node, AnimatedValue):
+                definition.update(kind="value", value=node.value)
+            elif isinstance(node, AnimatedInterpolation):
+                definition.update(
+                    kind="interpolate",
+                    inputs=[encode(node._parent)],
+                    ranges=node._inputs,
+                    outputs=node._outputs,
+                    color=node._kind == "color",
+                    left=node._left,
+                    right=node._right,
+                )
+            elif isinstance(node, _AnimatedOperation):
+                definition.update(kind=node._op, inputs=[encode(parent) for parent in node._parents])
+            elif isinstance(node, _AnimatedDiffClamp):
+                definition.update(
+                    kind="diff_clamp",
+                    inputs=[encode(node._parent)],
+                    minimum=node._min,
+                    maximum=node._max,
+                    previous=node._last_input,
+                    value=node.value,
+                )
+            else:
+                raise TypeError(f"Unsupported animated node {type(node).__name__}")
+            encoded[identity] = definition
+        return {"node": identity}
+
+    for node in connected.values():
+        encode(node)
+    bindings = [[tag, prop, id(node)] for node in connected.values() for tag, prop in node.attachments()]
+    return {"id": min(connected), "nodes": list(encoded.values()), "bindings": bindings}
+
+
+def install(node: Any, *, detached_tag: int | None = None) -> dict[str, Any] | None:
+    """Synchronize native graph ownership when a binding is attached or removed."""
+    from .animated import _backend
+
+    backend = _backend()
+    handler = getattr(backend, "install_animation_graph", None)
+    if handler is None:
+        return None
+    graph = serialize(node)
+    tag = graph["bindings"][0][0] if graph["bindings"] else detached_tag
+    if tag is not None:
+        handler(tag, graph)
+    return graph

{pythonnative-0.38.0 → pythonnative-0.40.0}/src/pythonnative/bootstrap.py

@@ -8,9 +8,10 @@ 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``.
+protocol version, routes ``print()`` to the console on iOS, warms the
+asyncio runtime, and, in debug builds, starts the dev client that syncs
+sources from ``pn start``. From then on the native runtime drives
+everything through ``callback("host", ...)``; see ``docs/concepts/bridge.md``.
 """
 
 from __future__ import annotations
@@ -29,14 +30,14 @@ 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.
+        dev: Enable dev mode (RedBox, validation warnings, the dev
+            client). Debug templates pass ``True``.
         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
+        A status dict (``{"protocol": 2, "platform": "ios"}``) that the
         template logs. Unless ``strict`` is set this never raises:
         failures are printed and reported in the dict under
         ``"error"``.
@@ -56,23 +57,32 @@ def start(dev: bool = False, strict: bool = False) -> Dict[str, Any]:
                 _ios_log.install()
             except Exception:
                 pass
+        from .runtime import start as start_runtime
+
+        start_runtime()
+        from .sdk.schema import load_bundled_contracts
+
+        load_bundled_contracts()
         from . import bridge
 
         status_["protocol"] = bridge.handshake()
-        if dev or os.environ.get("PN_DEV") in ("1", "true"):
+        dev_mode = bool(dev or os.environ.get("PN_DEV") in ("1", "true"))
+        if dev_mode:
             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()
+        if dev_mode:
+            # Debug builds are dev clients: connect to `pn start` when
+            # the build (or a remembered connection) names a server.
+            from . import devclient
+
+            client = devclient.start_if_configured()
+            status_["dev_server"] = client.url if client is not None else None
     except Exception as exc:
         status_["error"] = f"{type(exc).__name__}: {exc}"
         print(f"[pn.bootstrap] start failed: {exc!r}", file=sys.stderr)