pythonnative 0.19.0__tar.gz → 0.20.0__tar.gz

{pythonnative-0.19.0/src/pythonnative.egg-info → pythonnative-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.19.0
+Version: 0.20.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License
@@ -102,7 +102,7 @@ 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`, and navigation with `use_navigation`, all through one consistent pattern.
 - **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`.
 - **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.
+- **Virtual view tree + reconciler:** Element trees are diffed and patched with minimal native mutations, similar to React's reconciliation. 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.
 - **Direct native bindings:** Python calls platform APIs directly through Chaquopy and rubicon-objc, with no JavaScript bridge.
 - **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.

{pythonnative-0.19.0 → pythonnative-0.20.0}/README.md

@@ -36,7 +36,7 @@ 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`, and navigation with `use_navigation`, all through one consistent pattern.
 - **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`.
 - **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.
+- **Virtual view tree + reconciler:** Element trees are diffed and patched with minimal native mutations, similar to React's reconciliation. 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.
 - **Direct native bindings:** Python calls platform APIs directly through Chaquopy and rubicon-objc, with no JavaScript bridge.
 - **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.

{pythonnative-0.19.0 → pythonnative-0.20.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.19.0"
+version = "0.20.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }
@@ -72,6 +72,7 @@ Documentation = "https://docs.pythonnative.com/"
 
 
 
+
 [tool.setuptools.packages.find]
 where = ["src"]
 

{pythonnative-0.19.0 → pythonnative-0.20.0}/src/pythonnative/__init__.py

@@ -51,7 +51,7 @@ Example:
     ```
 """
 
-__version__ = "0.19.0"
+__version__ = "0.20.0"
 
 from . import runtime, sdk
 from .alerts import Alert

{pythonnative-0.19.0 → pythonnative-0.20.0}/src/pythonnative/hooks.py

@@ -76,6 +76,8 @@ class HookState:
         "_trigger_render",
         "_pending_effects",
         "_dirty",
+        "_vnode",
+        "_reconciler",
     )
 
     def __init__(self) -> None:
@@ -95,6 +97,13 @@ class HookState:
         # knows that a memoized component still needs to re-render even
         # when its props didn't change.
         self._dirty: bool = False
+        # Back-references wired by the reconciler so a state setter can
+        # mark *its own* component subtree dirty for a local re-render
+        # (instead of forcing a whole-app re-render from the root). Both
+        # stay ``None`` until the component is mounted, and are cleared
+        # again when it unmounts.
+        self._vnode: Any = None
+        self._reconciler: Any = None
 
     def reset_index(self) -> None:
         """Reset every per-hook cursor to ``0``.
@@ -182,6 +191,25 @@ def _schedule_trigger(trigger: Callable[[], None]) -> None:
         trigger()
 
 
+def _notify_state_changed(ctx: "HookState") -> None:
+    """Mark ``ctx``'s component dirty and schedule a render after a state change.
+
+    Enqueuing the owning ``VNode`` in the reconciler's dirty set is what
+    makes the subsequent render *local*: the screen host's trigger calls
+    ``flush_dirty``, which re-renders only the components marked here
+    rather than the whole app. The dirty mark is eager (so several
+    setters coalesce), while the render trigger respects
+    [`batch_updates`][pythonnative.batch_updates].
+    """
+    ctx._dirty = True
+    reconciler = ctx._reconciler
+    vnode = ctx._vnode
+    if reconciler is not None and vnode is not None:
+        reconciler.mark_dirty(vnode)
+    if ctx._trigger_render:
+        _schedule_trigger(ctx._trigger_render)
+
+
 @contextmanager
 def batch_updates() -> Generator[None, None, None]:
     """Coalesce multiple state updates into a single re-render.
@@ -272,9 +300,7 @@ def use_state(initial: Any = None) -> Tuple[Any, Callable]:
             new_value = new_value(ctx.states[idx])
         if ctx.states[idx] is not new_value and ctx.states[idx] != new_value:
             ctx.states[idx] = new_value
-            ctx._dirty = True
-            if ctx._trigger_render:
-                _schedule_trigger(ctx._trigger_render)
+            _notify_state_changed(ctx)
 
     return current, setter
 
@@ -339,9 +365,7 @@ def use_reducer(reducer: Callable[[Any, Any], Any], initial_state: Any) -> Tuple
         new_state = reducer(ctx.states[idx], action)
         if ctx.states[idx] is not new_state and ctx.states[idx] != new_state:
             ctx.states[idx] = new_state
-            ctx._dirty = True
-            if ctx._trigger_render:
-                _schedule_trigger(ctx._trigger_render)
+            _notify_state_changed(ctx)
 
     return current, dispatch
 

{pythonnative-0.19.0 → pythonnative-0.20.0}/src/pythonnative/reconciler.py

@@ -30,7 +30,7 @@ Supports:
 
 import os
 import sys
-from typing import Any, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 from .element import Element
 from .layout import LayoutNode, calculate_layout, extract_layout_style
@@ -106,19 +106,44 @@ class VNode:
             or an iOS `UIView`). May be `None` for purely virtual
             wrappers such as providers and error boundaries.
         children: Ordered list of child `VNode` instances.
+        parent: The owning `VNode`, or `None` for the tree root. Used
+            by local (component-scoped) re-renders to bubble a changed
+            native view up to the nearest native container.
         hook_state: The component's
             [`HookState`][pythonnative.hooks.HookState] when the node
             wraps a function component, otherwise `None`.
+        mounted: `False` once the node has been destroyed, so stale
+            entries in the reconciler's dirty set are skipped.
     """
 
-    __slots__ = ("element", "native_view", "children", "hook_state", "_rendered")
+    __slots__ = (
+        "element",
+        "native_view",
+        "children",
+        "parent",
+        "hook_state",
+        "mounted",
+        "_rendered",
+        "_measure_cache",
+    )
 
     def __init__(self, element: Element, native_view: Any, children: List["VNode"]) -> None:
         self.element = element
         self.native_view = native_view
         self.children = children
+        self.parent: Optional["VNode"] = None
         self.hook_state: Any = None
+        self.mounted: bool = True
         self._rendered: Optional[Element] = None
+        # Cache for the leaf intrinsic-size measure callback:
+        # ``(element, max_w, max_h, width, height)``. Lets the layout
+        # pass skip native ``measure_intrinsic`` calls for leaves whose
+        # element *object* (compared by identity) and constraints are
+        # unchanged since the last measure. Because untouched components
+        # keep their exact ``Element`` instances across a local
+        # re-render, this turns "re-measure everything every layout pass"
+        # into "re-measure only what actually re-rendered".
+        self._measure_cache: Optional[Tuple[Any, float, float, float, float]] = None
 
 
 class Reconciler:
@@ -142,6 +167,11 @@ class Reconciler:
         self._screen_re_render: Optional[Any] = None
         self._viewport_size: Tuple[float, float] = (0.0, 0.0)
         self._layout_pass = 0
+        # Function-component VNodes whose own state changed since the
+        # last flush, keyed by ``id`` to dedupe while keeping a strong
+        # reference. Drained by
+        # [`flush_dirty`][pythonnative.reconciler.Reconciler.flush_dirty].
+        self._dirty_nodes: Dict[int, VNode] = {}
 
     # ------------------------------------------------------------------
     # Public API
@@ -160,6 +190,7 @@ class Reconciler:
         self._log_viewport(
             f"mount: start type={self._type_label(element.type)!r} props={self._props_debug(element.props)}"
         )
+        self._dirty_nodes.clear()
         self._tree = self._create_tree(element)
         self._log_viewport(f"mount: tree created root={self._node_debug(self._tree)}")
         self._flush_effects()
@@ -181,6 +212,9 @@ class Reconciler:
             f"(have_tree={self._tree is not None}) new_type={self._type_label(new_element.type)!r} "
             f"new_props={self._props_debug(new_element.props)}"
         )
+        # A full reconcile rebuilds the whole tree from the root, so any
+        # pending per-component dirty marks are now obsolete.
+        self._dirty_nodes.clear()
         if self._tree is None:
             self._tree = self._create_tree(new_element)
             self._log_viewport(f"reconcile: created initial root={self._node_debug(self._tree)}")
@@ -195,6 +229,221 @@ class Reconciler:
         self._log_viewport("reconcile: done")
         return self._tree.native_view
 
+    def root_view(self) -> Any:
+        """Return the current root native view, or ``None`` before mount."""
+        return self._tree.native_view if self._tree is not None else None
+
+    def mark_dirty(self, vnode: "VNode") -> None:
+        """Queue ``vnode`` (a function component) for a local re-render.
+
+        Called by a component's ``use_state`` / ``use_reducer`` setter
+        when its own state changes. The node is re-rendered on the next
+        [`flush_dirty`][pythonnative.reconciler.Reconciler.flush_dirty]
+        pass, which the screen host schedules. Marking is idempotent and
+        cheap; the actual render is deferred so several setters (e.g.
+        inside [`batch_updates`][pythonnative.batch_updates]) coalesce
+        into a single pass.
+        """
+        if vnode is None or vnode.hook_state is None or not vnode.mounted:
+            return
+        self._dirty_nodes[id(vnode)] = vnode
+
+    def flush_dirty(self) -> Any:
+        """Re-render only the component subtrees marked dirty since the last pass.
+
+        This is the hot path for state-driven updates: instead of
+        re-running the whole app from the root, each dirty function
+        component re-runs its own body (reusing its
+        [`HookState`][pythonnative.hooks.HookState]) and reconciles just
+        its subtree. Nodes are processed shallowest-first so that when a
+        dirty ancestor's re-render already covers a dirty descendant, the
+        descendant is skipped (its ``_dirty`` flag is cleared by the
+        ancestor pass).
+
+        Returns:
+            The (possibly replaced) root native view, so the host can
+            re-attach it if the root changed.
+        """
+        if self._tree is None:
+            return None
+        if not self._dirty_nodes:
+            return self._tree.native_view
+
+        pending = list(self._dirty_nodes.values())
+        self._dirty_nodes.clear()
+        pending.sort(key=self._node_depth)
+        for vnode in pending:
+            if not vnode.mounted:
+                continue
+            hook_state = vnode.hook_state
+            if hook_state is None or not hook_state._dirty:
+                # Already re-rendered as part of a dirty ancestor's pass.
+                continue
+            try:
+                self._update_component(vnode)
+            except Exception as exc:
+                # A local re-render starts below any enclosing
+                # ``ErrorBoundary``, so route the failure to the nearest
+                # boundary ancestor (re-rendering its subtree through the
+                # boundary, which mounts the fallback). With no boundary
+                # the exception propagates, matching a full render.
+                self._handle_local_render_error(vnode, exc)
+
+        self._flush_effects()
+        self._run_layout()
+        return self._tree.native_view
+
+    @staticmethod
+    def _node_depth(vnode: "VNode") -> int:
+        depth = 0
+        node = vnode.parent
+        while node is not None:
+            depth += 1
+            node = node.parent
+        return depth
+
+    def _update_component(self, vnode: "VNode") -> None:
+        """Re-run one function component's body and reconcile its subtree in place.
+
+        Unlike a full reconcile from the root, a local update starts in
+        the *middle* of the tree, so the context stack of every
+        ``__Provider__`` ancestor must be re-established before the body
+        runs (otherwise [`use_context`][pythonnative.use_context] — and
+        therefore [`use_navigation`][pythonnative.use_navigation] — would
+        read the context default instead of the provided value). Nested
+        providers *inside* this subtree are pushed/popped normally by the
+        recursive reconcile beneath us.
+        """
+        from .hooks import _set_hook_state
+
+        new_el = vnode.element
+        if not callable(new_el.type):
+            return
+        hook_state = vnode.hook_state
+        if hook_state is None:
+            return
+
+        providers = self._ancestor_providers(vnode)
+        for context, value in providers:
+            context._stack.append(value)
+        try:
+            hook_state.reset_index()
+            hook_state._trigger_render = self._screen_re_render
+            hook_state._vnode = vnode
+            hook_state._reconciler = self
+            _set_hook_state(hook_state)
+            try:
+                rendered = new_el.type(**new_el.props)
+            finally:
+                _set_hook_state(None)
+                hook_state._dirty = False
+
+            old_native = vnode.native_view
+            if vnode.children:
+                child = self._reconcile_node(vnode.children[0], rendered)
+            else:
+                child = self._create_tree(rendered)
+        finally:
+            for context, _value in reversed(providers):
+                context._stack.pop()
+
+        child.parent = vnode
+        vnode.children = [child]
+        vnode.native_view = child.native_view
+        vnode._rendered = rendered
+
+        if child.native_view is not old_native:
+            self._bubble_native_view_change(vnode, old_native, child.native_view)
+
+    def _handle_local_render_error(self, vnode: "VNode", exc: Exception) -> None:
+        """Route a local re-render failure to the nearest ``ErrorBoundary`` ancestor.
+
+        Re-reconciles the boundary against its own element so the throw
+        is re-triggered *inside*
+        [`_reconcile_error_boundary`][pythonnative.reconciler.Reconciler._reconcile_error_boundary],
+        which destroys the failed subtree and mounts the boundary's
+        fallback. If no boundary encloses ``vnode`` the exception
+        propagates, exactly as it would during a full render.
+        """
+        node = vnode.parent
+        while node is not None:
+            if isinstance(node.element.type, str) and node.element.type == "__ErrorBoundary__":
+                old_native = node.native_view
+                # Like a local component update, this re-reconcile starts
+                # mid-tree, so restore the boundary's own ancestor
+                # provider context first.
+                providers = self._ancestor_providers(node)
+                for context, value in providers:
+                    context._stack.append(value)
+                try:
+                    self._reconcile_node(node, node.element)
+                finally:
+                    for context, _value in reversed(providers):
+                        context._stack.pop()
+                if node.native_view is not old_native:
+                    self._bubble_native_view_change(node, old_native, node.native_view)
+                return
+            node = node.parent
+        raise exc
+
+    @staticmethod
+    def _ancestor_providers(vnode: "VNode") -> List[Tuple[Any, Any]]:
+        """Collect ``(context, value)`` for every ``__Provider__`` above ``vnode``.
+
+        Returned outermost-first so that pushing them in order leaves the
+        nearest provider on top of each context's stack (nearest wins,
+        matching React).
+        """
+        chain: List[Tuple[Any, Any]] = []
+        node = vnode.parent
+        while node is not None:
+            el = node.element
+            if isinstance(el.type, str) and el.type == "__Provider__":
+                chain.append((el.props["__context__"], el.props["__value__"]))
+            node = node.parent
+        chain.reverse()
+        return chain
+
+    def _bubble_native_view_change(self, vnode: "VNode", old_native: Any, new_native: Any) -> None:
+        """Propagate a changed subtree-root native view up to its native parent.
+
+        A local re-render starts below the real native container, so when
+        the dirty component's root native view is swapped (e.g. its output
+        changed type), the change must be reflected in (a) every
+        transparent ancestor that delegated its ``native_view`` to this
+        subtree and (b) the nearest native-container ancestor's child list.
+        """
+        child = vnode
+        node = vnode.parent
+        while node is not None:
+            if self._is_native_container(node):
+                try:
+                    idx: Optional[int] = node.children.index(child)
+                except ValueError:
+                    idx = None
+                if old_native is not None:
+                    self.backend.remove_child(node.native_view, old_native, node.element.type)
+                if new_native is not None:
+                    if idx is None:
+                        self.backend.add_child(node.native_view, new_native, node.element.type)
+                    else:
+                        self.backend.insert_child(node.native_view, new_native, node.element.type, idx)
+                return
+            # Transparent ancestor (component / provider / error boundary /
+            # fragment) delegates its native view to this subtree.
+            if node.native_view is old_native:
+                node.native_view = new_native
+            child = node
+            node = node.parent
+        # Reached the root with no native container above: the root's
+        # ``native_view`` was already updated in the loop. The host
+        # detects the change by comparing ``root_view()`` after the flush.
+
+    @staticmethod
+    def _is_native_container(node: "VNode") -> bool:
+        t = node.element.type
+        return isinstance(t, str) and t not in ("__Provider__", "__ErrorBoundary__", "__Fragment__")
+
     def set_viewport_size(self, width: float, height: float) -> None:
         """Update the viewport size and re-run layout if it changed.
 
@@ -288,12 +537,24 @@ class Reconciler:
     # ------------------------------------------------------------------
 
     def _flush_effects(self) -> None:
-        """Walk the committed tree and flush pending effects (depth-first)."""
+        """Walk the committed tree and flush pending effects (depth-first).
+
+        This post-commit walk doubles as the single source of truth for
+        ``VNode.parent``: every live node's parent pointer is re-linked
+        here so that local re-renders
+        ([`flush_dirty`][pythonnative.reconciler.Reconciler.flush_dirty])
+        can compute node depth and bubble native-view changes upward
+        without each reconcile path having to maintain parent links by
+        hand. The cost is folded into a walk the reconciler already runs
+        after every commit.
+        """
         if self._tree is not None:
+            self._tree.parent = None
             self._flush_tree_effects(self._tree)
 
     def _flush_tree_effects(self, node: VNode) -> None:
         for child in node.children:
+            child.parent = node
             self._flush_tree_effects(child)
         if node.hook_state is not None:
             node.hook_state.flush_pending_effects()
@@ -347,6 +608,8 @@ class Reconciler:
             vnode = VNode(element, child_node.native_view, [child_node])
             vnode.hook_state = hook_state
             vnode._rendered = rendered
+            hook_state._vnode = vnode
+            hook_state._reconciler = self
             return vnode
 
         # Native element
@@ -478,6 +741,8 @@ class Reconciler:
             old.element = new_el
             old.hook_state = hook_state
             old._rendered = rendered
+            hook_state._vnode = old
+            hook_state._reconciler = self
             return old
 
         # Native element
@@ -667,13 +932,25 @@ class Reconciler:
         )
 
     def _destroy_tree(self, node: VNode) -> None:
+        node.mounted = False
+        # Drop the node from the pending-render set so a setter that
+        # fired moments before unmount can't resurrect a dead subtree.
+        self._dirty_nodes.pop(id(node), None)
         if node.hook_state is not None:
             node.hook_state.cleanup_all_effects()
+            # Break the back-references so the unmounted component's hook
+            # state (and the closures it captured) can be freed by plain
+            # refcounting — important on iOS, where the cyclic GC is
+            # disabled.
+            node.hook_state._vnode = None
+            node.hook_state._reconciler = None
+            node.hook_state._trigger_render = None
         if node.element is not None:
             self._detach_ref(node.element)
         for child in node.children:
             self._destroy_tree(child)
         node.children = []
+        node.parent = None
 
     @staticmethod
     def _strip_reconciler_props(props: dict) -> dict:
@@ -935,6 +1212,10 @@ class Reconciler:
         node_label = self._node_debug(vnode)
 
         def measure(max_w: float, max_h: float) -> Tuple[float, float]:
+            cache = vnode._measure_cache
+            if cache is not None and cache[0] is vnode.element and cache[1] == max_w and cache[2] == max_h:
+                self._log_viewport(f"measure: cache hit type={type_name!r} result=({cache[3]!r},{cache[4]!r})")
+                return (cache[3], cache[4])
             try:
                 self._log_viewport(
                     "measure: before backend.measure_intrinsic " f"{node_label} max=({max_w!r},{max_h!r})"
@@ -942,6 +1223,7 @@ class Reconciler:
                 w, h = backend.measure_intrinsic(view, type_name, max_w, max_h)
                 result = (float(w), float(h))
                 self._log_viewport(f"measure: after backend.measure_intrinsic type={type_name!r} result={result!r}")
+                vnode._measure_cache = (vnode.element, max_w, max_h, result[0], result[1])
                 return result
             except Exception as e:
                 self._log_viewport(

{pythonnative-0.19.0 → pythonnative-0.20.0}/src/pythonnative/screen.py

@@ -322,53 +322,49 @@ def _request_render(host: Any) -> None:
 
 
 def _re_render(host: Any) -> None:
-    """Run one render pass, then drain any renders queued during it."""
-    from .hooks import Provider, _NavigationContext
-
-    _log_pn("_re_render: starting render pass")
+    """Run one *local* render pass, then drain any renders queued during it.
+
+    State setters mark only their own component subtree dirty (see
+    [`mark_dirty`][pythonnative.reconciler.Reconciler.mark_dirty]), so
+    this drains the reconciler's dirty set via
+    [`flush_dirty`][pythonnative.reconciler.Reconciler.flush_dirty]
+    instead of re-running the whole ``App`` from the root. The app's
+    element tree is only rebuilt from scratch on mount, navigation, and
+    hot reload.
+    """
+    _log_pn("_re_render: starting local render pass")
     host._is_rendering = True
     try:
         host._render_queued = False
-
-        app_element = _render_app(host)
-        provider_element = Provider(_NavigationContext, host._nav_handle, app_element)
-
-        new_root = host._reconciler.reconcile(provider_element)
-        if new_root is not host._root_native_view:
-            _log_pn(f"_re_render: ROOT VIEW CHANGED ({id(host._root_native_view)} -> {id(new_root)}); reattaching")
-            host._detach_root(host._root_native_view)
-            host._root_native_view = new_root
-            host._attach_root(new_root)
-
+        _commit_dirty(host)
         _drain_renders(host)
     finally:
         host._is_rendering = False
     _log_pn("_re_render: done")
 
 
+def _commit_dirty(host: Any) -> None:
+    """Flush the reconciler's dirty components and re-attach the root if it changed."""
+    new_root = host._reconciler.flush_dirty()
+    if new_root is not host._root_native_view:
+        _log_pn(f"_commit_dirty: ROOT VIEW CHANGED ({id(host._root_native_view)} -> {id(new_root)}); reattaching")
+        host._detach_root(host._root_native_view)
+        host._root_native_view = new_root
+        host._attach_root(new_root)
+
+
 def _drain_renders(host: Any) -> None:
     """Flush additional renders queued by effects that set state.
 
     Capped at `_MAX_RENDER_PASSES` to break runaway feedback loops
     (e.g., an effect that unconditionally calls a setter).
     """
-    from .hooks import Provider, _NavigationContext
-
     for i in range(_MAX_RENDER_PASSES):
         if not host._render_queued:
             break
         _log_pn(f"_drain_renders: draining pass #{i + 1}")
         host._render_queued = False
-
-        app_element = _render_app(host)
-        provider_element = Provider(_NavigationContext, host._nav_handle, app_element)
-
-        new_root = host._reconciler.reconcile(provider_element)
-        if new_root is not host._root_native_view:
-            _log_pn(f"_drain_renders: ROOT VIEW CHANGED ({id(host._root_native_view)} -> {id(new_root)}); reattaching")
-            host._detach_root(host._root_native_view)
-            host._root_native_view = new_root
-            host._attach_root(new_root)
+        _commit_dirty(host)
 
 
 def _set_args(host: Any, args: Any) -> None:

{pythonnative-0.19.0 → pythonnative-0.20.0/src/pythonnative.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.19.0
+Version: 0.20.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License
@@ -102,7 +102,7 @@ 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`, and navigation with `use_navigation`, all through one consistent pattern.
 - **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`.
 - **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.
+- **Virtual view tree + reconciler:** Element trees are diffed and patched with minimal native mutations, similar to React's reconciliation. 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.
 - **Direct native bindings:** Python calls platform APIs directly through Chaquopy and rubicon-objc, with no JavaScript bridge.
 - **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.

{pythonnative-0.19.0 → pythonnative-0.20.0}/src/pythonnative.egg-info/SOURCES.txt

@@ -113,6 +113,7 @@ tests/test_element.py
 tests/test_extended_components.py
 tests/test_hooks.py
 tests/test_hot_reload.py
+tests/test_incremental_render.py
 tests/test_ios_log.py
 tests/test_layout.py
 tests/test_metric_hooks.py