pythonnative 0.53.1__tar.gz → 0.54.0__tar.gz

{pythonnative-0.53.1/src/pythonnative.egg-info → pythonnative-0.54.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.53.1
+Version: 0.54.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License
@@ -80,11 +80,11 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 - **Declarative components and hooks:** Describe native UI with Python functions, immutable elements, and typed styles. State, effects, context, and suspense boundaries follow one logical application tree across screens, overlays, and mounted list rows. State updates batch automatically, effect errors reach the nearest error boundary, and event callbacks receive typed records instead of dicts.
 - **React Native's core surface:** `Pressable`, `ScrollView`, `Text`, `TextInput`, `Image`, `Modal`, `FlatList`, and `SectionList` carry the props a React Native developer expects (disabled state and ripples, content insets and snapping, ellipsize modes and pressable spans, controlled selection and key events, sticky headers and inverted lists), plus typed imperative handles on `ref.current` and the full accessibility prop set.
 - **Native widgets and layout:** Swift and Kotlin component managers own UIKit and Android widgets. The renderer core validates commits, lays out with Yoga off the UI thread using platform measurements for text and intrinsic sizes, and skips mounting layout-only wrappers.
-- **Standard asyncio:** Components, effects, event handlers, and tasks run on a dedicated Python application thread. Native UI threads handle widgets, scrolling, and animation frames. Component-owned tasks are canceled on unmount.
+- **Standard asyncio:** Components, effects, event handlers, and tasks run on a dedicated Python application thread. Native UI threads handle widgets, scrolling, animation frames, and worklets. Component-owned tasks are canceled on unmount.
 - **Incremental reconciliation:** State changes update affected component subtrees. Versioned bridge commits validate operations and acknowledge revisions; events and controlled text inputs carry identities that prevent stale updates.
-- **Typed, Pythonic authoring:** Components return `pn.Node` and their signatures are their props, so a strict type checker verifies element trees and conditional children. Screens are components whose parameters are their route params (`nav.push(ItemScreen(id=42))`), navigators are module-level values with deep links derived from each screen's `path`, one `Theme` dataclass styles the app and its navigators, `StyleSheet` namespaces give styles typed names, and `pn.Store` holds app state with selector-based re-renders. `pn lint` checks the rules of hooks.
+- **Typed, Pythonic authoring:** Components return `pn.Node` and their signatures are their props, so a strict type checker verifies element trees and conditional children. Screens are components whose parameters are their route params (`nav.push(ItemScreen(id=42))`), navigators are module-level values with deep links derived from each screen's `path`, one `Theme` dataclass styles the app and its navigators, `StyleSheet` namespaces give styles typed names, and `pn.Store` holds app state with selector-based re-renders. `pn lint` checks the rules of hooks and that worklets compile.
 - **Native lists and navigation:** UIKit collection views and Android recycler views recycle cells for fixed or variable row sizes, grids, sections, and horizontal lists. Native navigation containers present logical screen roots at every nesting level while providers and component state remain in the shared Python tree; navigators take screen options, groups, tab-bar styles, and a navigation ref usable outside components.
-- **Animation and gestures:** Serialized animation graphs support timing with named or bezier easing, springs, React Native's decay model, arithmetic, interpolation, and native scroll and gesture bindings. Gestures activate with Gesture Handler-style offsets and update supported animation bindings without Python work on every frame.
+- **Motion:** Interaction logic runs on the UI thread as worklets, ordinary type-checked Python functions marked `@pn.worklet` that the renderer core compiles and runs, so a drag keeps tracking and a release decides where to settle while Python is busy. Shared values, `with_timing`, `with_spring`, and `with_decay` animations (awaitable from Python), and animated styles drive paint and layout properties; scroll events and gesture callbacks take worklets; `entering=`, `exiting=`, and `layout=` animate views as the tree changes, including native list rows; and `shared_tag=` flies an element between stack screens. `BottomSheet`, `Swipeable`, and a drawer that follows the finger are built on it. Gestures activate with Gesture Handler-style offsets and composition.
 - **Assets and graphics:** Drop images, fonts, and SVGs under `app/assets/` and reference them by path. Density variants, bundled fonts, a vector `Icon` set, `Svg` drawing, gradients, and blur render natively on both platforms and in the browser preview.
 - **Device APIs:** Python facades expose storage, permissions, keyboard, dimensions and pixel ratio, device info, localization, accessibility settings, haptics, and other native services in every app, with a Python fallback for headless tests. Test permissions and platform behavior on your deployment targets.
 - **First-party capabilities:** Video, audio, camera, maps, location, notifications, push, pickers, sensors, biometrics, background tasks, and in-app purchases ship in the package and compile into your app only when you list them: `[plugins] use = ["camera", "maps"]` in `pythonnative.toml`, then `from pythonnative.camera import CameraView`. An app that doesn't list one contains none of its code, and calling it raises `plugin_not_enabled`. Simulators can't prove everything here: camera capture on iOS, remote push, and purchases need real hardware or store credentials.

{pythonnative-0.53.1 → pythonnative-0.54.0}/README.md

@@ -33,11 +33,11 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 - **Declarative components and hooks:** Describe native UI with Python functions, immutable elements, and typed styles. State, effects, context, and suspense boundaries follow one logical application tree across screens, overlays, and mounted list rows. State updates batch automatically, effect errors reach the nearest error boundary, and event callbacks receive typed records instead of dicts.
 - **React Native's core surface:** `Pressable`, `ScrollView`, `Text`, `TextInput`, `Image`, `Modal`, `FlatList`, and `SectionList` carry the props a React Native developer expects (disabled state and ripples, content insets and snapping, ellipsize modes and pressable spans, controlled selection and key events, sticky headers and inverted lists), plus typed imperative handles on `ref.current` and the full accessibility prop set.
 - **Native widgets and layout:** Swift and Kotlin component managers own UIKit and Android widgets. The renderer core validates commits, lays out with Yoga off the UI thread using platform measurements for text and intrinsic sizes, and skips mounting layout-only wrappers.
-- **Standard asyncio:** Components, effects, event handlers, and tasks run on a dedicated Python application thread. Native UI threads handle widgets, scrolling, and animation frames. Component-owned tasks are canceled on unmount.
+- **Standard asyncio:** Components, effects, event handlers, and tasks run on a dedicated Python application thread. Native UI threads handle widgets, scrolling, animation frames, and worklets. Component-owned tasks are canceled on unmount.
 - **Incremental reconciliation:** State changes update affected component subtrees. Versioned bridge commits validate operations and acknowledge revisions; events and controlled text inputs carry identities that prevent stale updates.
-- **Typed, Pythonic authoring:** Components return `pn.Node` and their signatures are their props, so a strict type checker verifies element trees and conditional children. Screens are components whose parameters are their route params (`nav.push(ItemScreen(id=42))`), navigators are module-level values with deep links derived from each screen's `path`, one `Theme` dataclass styles the app and its navigators, `StyleSheet` namespaces give styles typed names, and `pn.Store` holds app state with selector-based re-renders. `pn lint` checks the rules of hooks.
+- **Typed, Pythonic authoring:** Components return `pn.Node` and their signatures are their props, so a strict type checker verifies element trees and conditional children. Screens are components whose parameters are their route params (`nav.push(ItemScreen(id=42))`), navigators are module-level values with deep links derived from each screen's `path`, one `Theme` dataclass styles the app and its navigators, `StyleSheet` namespaces give styles typed names, and `pn.Store` holds app state with selector-based re-renders. `pn lint` checks the rules of hooks and that worklets compile.
 - **Native lists and navigation:** UIKit collection views and Android recycler views recycle cells for fixed or variable row sizes, grids, sections, and horizontal lists. Native navigation containers present logical screen roots at every nesting level while providers and component state remain in the shared Python tree; navigators take screen options, groups, tab-bar styles, and a navigation ref usable outside components.
-- **Animation and gestures:** Serialized animation graphs support timing with named or bezier easing, springs, React Native's decay model, arithmetic, interpolation, and native scroll and gesture bindings. Gestures activate with Gesture Handler-style offsets and update supported animation bindings without Python work on every frame.
+- **Motion:** Interaction logic runs on the UI thread as worklets, ordinary type-checked Python functions marked `@pn.worklet` that the renderer core compiles and runs, so a drag keeps tracking and a release decides where to settle while Python is busy. Shared values, `with_timing`, `with_spring`, and `with_decay` animations (awaitable from Python), and animated styles drive paint and layout properties; scroll events and gesture callbacks take worklets; `entering=`, `exiting=`, and `layout=` animate views as the tree changes, including native list rows; and `shared_tag=` flies an element between stack screens. `BottomSheet`, `Swipeable`, and a drawer that follows the finger are built on it. Gestures activate with Gesture Handler-style offsets and composition.
 - **Assets and graphics:** Drop images, fonts, and SVGs under `app/assets/` and reference them by path. Density variants, bundled fonts, a vector `Icon` set, `Svg` drawing, gradients, and blur render natively on both platforms and in the browser preview.
 - **Device APIs:** Python facades expose storage, permissions, keyboard, dimensions and pixel ratio, device info, localization, accessibility settings, haptics, and other native services in every app, with a Python fallback for headless tests. Test permissions and platform behavior on your deployment targets.
 - **First-party capabilities:** Video, audio, camera, maps, location, notifications, push, pickers, sensors, biometrics, background tasks, and in-app purchases ship in the package and compile into your app only when you list them: `[plugins] use = ["camera", "maps"]` in `pythonnative.toml`, then `from pythonnative.camera import CameraView`. An app that doesn't list one contains none of its code, and calling it raises `plugin_not_enabled`. Simulators can't prove everything here: camera capture on iOS, remote push, and purchases need real hardware or store credentials.

{pythonnative-0.53.1 → pythonnative-0.54.0}/pyproject.toml

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

{pythonnative-0.53.1 → pythonnative-0.54.0}/src/pythonnative/__init__.py

@@ -35,10 +35,13 @@ Key building blocks:
   its navigators.
 - **State** lives in hooks for a component and in a typed
   [`Store`][pythonnative.Store] for the app.
-- **Animations** use the ``Animated`` namespace. Serialized graphs
-  connect values, arithmetic, interpolation, and style bindings.
-  Native timing, spring, decay, scroll, and gesture drivers update
-  supported bindings without Python work on every frame.
+- **Motion** (RFC 0009): [`worklet`][pythonnative.worklet] functions run
+  on the UI thread inside the renderer core. They read and write
+  [`SharedValue`][pythonnative.SharedValue]s, which
+  [`use_animated_style`][pythonnative.use_animated_style] turns into
+  styles and ``with_timing`` / ``with_spring`` / ``with_decay`` animate.
+  Event props and gesture callbacks take worklets, and views take
+  ``entering=``, ``exiting=``, ``layout=``, and ``shared_tag=``.
 - **Gestures** attach to any view via the ``gestures=`` prop using
   descriptors from ``pythonnative.gestures``
   ([`Tap`][pythonnative.gestures.Tap],
@@ -81,7 +84,7 @@ Example:
     ```
 """
 
-__version__ = "0.53.1"
+__version__ = "0.54.0"
 
 import importlib
 from typing import TYPE_CHECKING, Any
@@ -138,7 +141,7 @@ from .components import (
     WebView,
     set_error_fallback,
 )
-from .components.props import AccessibilityProps, ViewProps
+from .components.props import AccessibilityProps, CommonProps, MotionProps, ViewProps
 from .diagnostics import HookOrderError, set_error_handler
 from .element import Element, Node
 from .handles import ScrollOffset, ScrollViewHandle, TextInputHandle, ViewHandle, WebViewHandle
@@ -214,6 +217,7 @@ from .style import (
     AccessibilityAction,
     AccessibilityState,
     AccessibilityValue,
+    AnimatedStyle,
     Color,
     DynamicColor,
     EdgeInsets,
@@ -293,6 +297,8 @@ __all__ = [
     "WebView",
     # Shared props
     "AccessibilityProps",
+    "CommonProps",
+    "MotionProps",
     "ViewProps",
     # Typed events
     "ContentSizeEvent",
@@ -396,13 +402,34 @@ __all__ = [
     "use_theme",
     # Appearance
     "appearance",
-    # Animation
-    "Animated",
-    "AnimatedValue",
-    "AnimationResult",
+    # Motion
+    "motion",
+    "AnimatedStyle",
+    "BottomSheet",
+    "BottomSheetHandle",
     "Easing",
-    "EasingSpec",
-    "use_animated_value",
+    "FrameInfo",
+    "SharedValue",
+    "Spring",
+    "Swipeable",
+    "SwipeableHandle",
+    "clamp",
+    "interpolate",
+    "interpolate_color",
+    "run_on_python",
+    "snap_point",
+    "use_animated_reaction",
+    "use_animated_style",
+    "use_derived_value",
+    "use_frame_callback",
+    "use_shared_value",
+    "with_decay",
+    "with_delay",
+    "with_repeat",
+    "with_sequence",
+    "with_spring",
+    "with_timing",
+    "worklet",
     # Gestures
     "GestureSpec",
     "SwipeDirection",
@@ -466,14 +493,31 @@ from .list_data import ListData, Section, ViewableItem
 # ``import pythonnative`` stays fast on a phone. Names, ``__all__``, and
 # documentation are unchanged, and type checkers see ordinary imports.
 _LAZY_GROUPS: dict[str, tuple[str, ...]] = {
-    "animated": (
-        "Animated",
-        "AnimatedValue",
-        "AnimationResult",
+    "motion": (
         "Easing",
-        "EasingSpec",
-        "use_animated_value",
+        "FrameInfo",
+        "SharedValue",
+        "Spring",
+        "clamp",
+        "interpolate",
+        "interpolate_color",
+        "run_on_python",
+        "snap_point",
+        "use_animated_reaction",
+        "use_animated_style",
+        "use_derived_value",
+        "use_frame_callback",
+        "use_shared_value",
+        "with_decay",
+        "with_delay",
+        "with_repeat",
+        "with_sequence",
+        "with_spring",
+        "with_timing",
+        "worklet",
     ),
+    "components.bottom_sheet": ("BottomSheet", "BottomSheetHandle"),
+    "components.swipeable": ("Swipeable", "SwipeableHandle"),
     "gestures": ("GestureSpec", "SwipeDirection"),
     "icons": ("Icon", "IconName"),
     "navigation": (
@@ -500,20 +544,37 @@ _LAZY_GROUPS: dict[str, tuple[str, ...]] = {
     "websocket": ("WebSocket", "WebSocketClosed", "WebSocketError"),
 }
 _LAZY = {name: module for module, names in _LAZY_GROUPS.items() for name in names}
-_LAZY_MODULES = frozenset({"gestures", "icons"})
+_LAZY_MODULES = frozenset({"gestures", "icons", "motion"})
 
 if TYPE_CHECKING:
-    from . import gestures, icons
-    from .animated import (
-        Animated,
-        AnimatedValue,
-        AnimationResult,
-        Easing,
-        EasingSpec,
-        use_animated_value,
-    )
+    from . import gestures, icons, motion
+    from .components.bottom_sheet import BottomSheet, BottomSheetHandle
+    from .components.swipeable import Swipeable, SwipeableHandle
     from .gestures import GestureSpec, SwipeDirection
     from .icons import Icon, IconName
+    from .motion import (
+        Easing,
+        FrameInfo,
+        SharedValue,
+        Spring,
+        clamp,
+        interpolate,
+        interpolate_color,
+        run_on_python,
+        snap_point,
+        use_animated_reaction,
+        use_animated_style,
+        use_derived_value,
+        use_frame_callback,
+        use_shared_value,
+        with_decay,
+        with_delay,
+        with_repeat,
+        with_sequence,
+        with_spring,
+        with_timing,
+        worklet,
+    )
     from .navigation import (
         DrawerNavigator,
         Group,

{pythonnative-0.53.1 → pythonnative-0.54.0}/src/pythonnative/audio/native/schema.json

@@ -353,6 +353,6 @@
       "name": "Audio"
     }
   },
-  "protocol": 7,
+  "protocol": 8,
   "yoga": "3.2.1"
 }

{pythonnative-0.53.1 → pythonnative-0.54.0}/src/pythonnative/background/native/schema.json

@@ -115,6 +115,6 @@
       "name": "Background"
     }
   },
-  "protocol": 7,
+  "protocol": 8,
   "yoga": "3.2.1"
 }

{pythonnative-0.53.1 → pythonnative-0.54.0}/src/pythonnative/biometrics/native/schema.json

@@ -32,6 +32,6 @@
       "name": "Biometrics"
     }
   },
-  "protocol": 7,
+  "protocol": 8,
   "yoga": "3.2.1"
 }

{pythonnative-0.53.1 → pythonnative-0.54.0}/src/pythonnative/bridge/__init__.py

@@ -59,8 +59,11 @@ class Transport(Protocol):
     def command(self, surface: int, tag: int, name: str, args_json: str, call_id: int) -> str:
         """Queue a view command; its result arrives as a ``command`` message."""
 
-    def animate(self, surface: int, tag: int, request_json: str) -> str:
-        """Queue an animation request behind pending mounts."""
+    def motion(self, surface: int, request_json: str) -> str:
+        """Queue a motion request behind pending mounts (RFC 0009)."""
+
+    def shared_read(self, ident: int) -> str:
+        """The latest value the UI thread published for a shared value, as JSON."""
 
     def measure(self, surface: int, tag: int) -> str:
         """The shadow and window frames of a view, as JSON."""
@@ -286,10 +289,10 @@ def dispatch(kind: str, tag: int, name: str, payload: str, backend: Any = None)
                 from ..hosts.native import dispatch_host_event
 
                 dispatch_host_event(int(tag), name, codec.loads(payload))
-        elif kind == "animation":
-            from ..animated import native_animation_message
+        elif kind == "motion":
+            from ..motion.runtime import motion_message
 
-            native_animation_message(codec.loads(payload) or {})
+            motion_message(codec.loads(payload) or {})
         else:
             print(f"[pn.bridge] unknown callback kind {kind!r}")
     except Exception as exc:

{pythonnative-0.53.1 → pythonnative-0.54.0}/src/pythonnative/bridge/android.py

@@ -61,9 +61,13 @@ class AndroidTransport:
         """Queue a view command behind pending mounts."""
         return self.core.command(surface, tag, name, args_json, call_id)
 
-    def animate(self, surface: int, tag: int, request_json: str) -> str:
-        """Queue an animation request behind pending mounts."""
-        return self.core.animate(surface, tag, request_json)
+    def motion(self, surface: int, request_json: str) -> str:
+        """Queue a motion request behind pending mounts (RFC 0009)."""
+        return self.core.motion(surface, request_json)
+
+    def shared_read(self, ident: int) -> str:
+        """The latest value the UI thread published for a shared value, as JSON."""
+        return self.core.shared_read(ident)
 
     def measure(self, surface: int, tag: int) -> str:
         """The shadow and window frames of a view."""

{pythonnative-0.53.1 → pythonnative-0.54.0}/src/pythonnative/bridge/codec.py

@@ -95,8 +95,8 @@ def split_props(
     ``wire_props`` is JSON-ready; ``python_props`` holds callbacks and
     fields explicitly declared Python-only. Other unsupported values
     fail encoding. The backend keeps Python props in a per-tag sidecar.
-    (The reconciler has already published ``Animated.event`` bindings
-    under ``_pn_animated_events`` before props reach the codec.)
+    (The reconciler has already turned worklet handlers and animated
+    styles into ``_pn_motion`` bindings before props reach the codec.)
     """
     wire: Dict[str, Any] = {}
     python: Dict[str, Any] = {}

{pythonnative-0.53.1 → pythonnative-0.54.0}/src/pythonnative/bridge/core.py

@@ -21,6 +21,7 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Callable, List, Optional, Sequence, Tuple
 
 __all__ = [
+    "MotionWrite",
     "MountOp",
     "MountTransaction",
     "Platform",
@@ -30,7 +31,7 @@ __all__ = [
     "load_core",
 ]
 
-PROTOCOL_VERSION = 7
+PROTOCOL_VERSION = 8
 """The protocol ``include/pn_core.h`` defines as ``PN_CORE_PROTOCOL_VERSION``."""
 
 MEASURE_TEXT = 1
@@ -130,6 +131,25 @@ class MountOp:
     name: str = ""
     arguments: Any = None
     call_id: int = 0
+    owner: int = 0
+    """``exit`` ops: 0 when the core animates the view out, 1 when the platform does."""
+
+
+@dataclass(frozen=True)
+class MotionWrite:
+    """One record of the core's motion writes (RFC 0009).
+
+    ``kind`` is ``"prop"`` (``tag``, ``prop``, ``value``), ``"frame"``
+    (``tag``, ``frame``), or ``"remove"`` (``tags``: an exit finished,
+    destroy each, children first).
+    """
+
+    kind: str
+    tag: int = 0
+    prop: str = ""
+    value: Any = None
+    frame: Tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0)
+    tags: Tuple[int, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -217,15 +237,34 @@ def decode_transaction(data: bytes) -> MountTransaction:
             name = reader.string()
             arguments = reader.value()
             ops.append(MountOp("command", tag, name=name, arguments=arguments, call_id=reader.take("q")))
+        elif code == 8:
+            tag = reader.take("q")
+            ops.append(MountOp("exit", tag, owner=reader.take("B")))
         else:
             raise ValueError(f"Unknown mount op {code}")
     return MountTransaction(surface, revision, ident, tuple(ops))
 
 
-def decode_writes(data: bytes) -> List[Tuple[int, str, Any]]:
-    """Decode animated prop writes into ``(tag, prop, value)`` tuples."""
+def decode_writes(data: bytes) -> List[MotionWrite]:
+    """Decode the core's motion writes into [`MotionWrite`][pythonnative.bridge.core.MotionWrite] records."""
     reader = _Reader(data)
-    return [(reader.take("q"), reader.string(), reader.value()) for _ in range(reader.take("I"))]
+    writes: List[MotionWrite] = []
+    for _ in range(reader.take("I")):
+        kind = reader.take("B")
+        if kind == 0:
+            tag = reader.take("q")
+            prop = reader.string()
+            writes.append(MotionWrite("prop", tag, prop=prop, value=reader.value()))
+        elif kind == 1:
+            tag = reader.take("q")
+            frame = (reader.take("d"), reader.take("d"), reader.take("d"), reader.take("d"))
+            writes.append(MotionWrite("frame", tag, frame=frame))
+        elif kind == 2:
+            count = reader.take("I")
+            writes.append(MotionWrite("remove", tags=tuple(reader.take("q") for _ in range(count))))
+        else:
+            raise ValueError(f"Unknown motion write kind {kind}")
+    return writes
 
 
 def decode_value(data: bytes) -> Any:
@@ -248,7 +287,14 @@ _SIGNATURES: dict[str, Tuple[Any, List[Any]]] = {
         ctypes.c_void_p,
         [ctypes.c_void_p, ctypes.c_int64, ctypes.c_int64, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int64],
     ),
-    "pn_core_animate": (ctypes.c_void_p, [ctypes.c_void_p, ctypes.c_int64, ctypes.c_int64, ctypes.c_char_p]),
+    "pn_core_motion": (ctypes.c_void_p, [ctypes.c_void_p, ctypes.c_int64, ctypes.c_char_p]),
+    "pn_core_shared_read": (ctypes.c_void_p, [ctypes.c_void_p, ctypes.c_int64]),
+    "pn_core_worklet_eval": (ctypes.c_void_p, [ctypes.c_char_p]),
+    "pn_core_exit_finished": (None, [ctypes.c_void_p, ctypes.c_int64, ctypes.c_int64]),
+    "pn_core_shared_elements": (
+        ctypes.c_void_p,
+        [ctypes.c_void_p, ctypes.c_int64, ctypes.c_int64, ctypes.c_int64],
+    ),
     "pn_core_measure": (ctypes.c_void_p, [ctypes.c_void_p, ctypes.c_int64, ctypes.c_int64]),
     "pn_core_inspect": (ctypes.c_void_p, [ctypes.c_void_p, ctypes.c_int64, ctypes.c_double, ctypes.c_double]),
     "pn_core_validate_module": (ctypes.c_int32, [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p]),
@@ -429,9 +475,17 @@ class RendererCore:
             self._take(self._command(self._handle, surface, tag, name.encode(), self._bytes(arguments), call_id)) or ""
         )
 
-    def animate(self, surface: int, tag: int, request: str) -> str:
-        """Queue an animation request behind pending mounts."""
-        return self._take(self._animate(self._handle, surface, tag, self._bytes(request))) or ""
+    def motion(self, surface: int, request: str) -> str:
+        """Queue a motion request behind pending mounts (RFC 0009)."""
+        return self._take(self._motion(self._handle, surface, self._bytes(request))) or ""
+
+    def shared_read(self, ident: int) -> str:
+        """The latest published value of a shared value, as JSON."""
+        return self._take(self._shared_read(self._handle, ident)) or "null"
+
+    def worklet_eval(self, request: str) -> str:
+        """Run one worklet outside the runtime and return the result JSON."""
+        return self._take(self._worklet_eval(self._bytes(request))) or ""
 
     def measure(self, surface: int, tag: int) -> str:
         """The shadow frame and window frame of ``tag`` as JSON (``"null"`` when unknown)."""
@@ -495,13 +549,21 @@ class RendererCore:
         """Advance animations; returns whether more frames are needed."""
         return bool(self._animation_frame(self._handle, timestamp_ms))
 
-    def take_writes(self) -> List[Tuple[int, str, Any]]:
-        """Animated prop writes produced since the last call."""
+    def take_writes(self) -> List[MotionWrite]:
+        """Motion writes produced since the last call."""
         buffer = _Bytes()
         if not self._take_writes(self._handle, ctypes.byref(buffer)):
             return []
         return decode_writes(ctypes.string_at(buffer.data, buffer.size))
 
+    def exit_finished(self, surface: int, tag: int) -> None:
+        """Report a platform-owned exit (a leaving screen or modal) finished."""
+        self._exit_finished(self._handle, surface, tag)
+
+    def shared_elements(self, surface: int, from_screen: int, to_screen: int) -> str:
+        """The views sharing a ``shared_tag`` between two screens, as JSON."""
+        return self._take(self._shared_elements(self._handle, surface, from_screen, to_screen)) or "[]"
+
     def set_reduce_motion(self, enabled: bool) -> None:
         """Finish every animation at its target, as the platform's setting asks."""
         self._set_reduce_motion(self._handle, int(enabled))

{pythonnative-0.53.1 → pythonnative-0.54.0}/src/pythonnative/bridge/fake.py

@@ -24,7 +24,16 @@ import weakref
 from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
 
 from . import codec
-from .core import PROTOCOL_VERSION, MountOp, MountTransaction, Platform, RendererCore, decode_transaction, load_core
+from .core import (
+    PROTOCOL_VERSION,
+    MotionWrite,
+    MountOp,
+    MountTransaction,
+    Platform,
+    RendererCore,
+    decode_transaction,
+    load_core,
+)
 
 __all__ = ["DEFAULT_MEASURE", "FakeNativeView", "FakeTransport", "reset_fakes"]
 
@@ -40,6 +49,15 @@ class FakeNativeView:
         self.parent: Optional["FakeNativeView"] = None
         self.frame: Tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0)
         self.animated: Dict[str, Any] = {}
+        """Paint props motion wrote, overriding ``props`` (RFC 0009)."""
+        self.exiting: Optional[int] = None
+        """The ``exit`` op's owner while the view animates out, else ``None``."""
+
+    def presented(self, key: str) -> Any:
+        """The value the platform shows for ``key``: motion's write, else the committed prop."""
+        if key in self.animated:
+            return self.animated[key]
+        return self.props.get(key)
 
     def __repr__(self) -> str:
         return f"<native {self.type_name} tag={self.tag}>"
@@ -145,13 +163,11 @@ def _frame() -> None:
 def _take_writes() -> None:
     if _installed is None:
         return
-    for tag, prop, value in _installed.take_writes():
+    for write in _installed.take_writes():
+        tag = write.tags[0] if write.kind == "remove" and write.tags else write.tag
         for transport in list(_transports.values()):
-            view = transport.views.get(tag)
-            if view is not None or transport.owns(tag):
-                transport.writes.append((tag, prop, value))
-                if view is not None:
-                    view.animated[prop] = value
+            if tag in transport.views or transport.owns(tag):
+                transport._write(write)
                 break
 
 
@@ -179,6 +195,12 @@ def _mount_all() -> None:
                     error = str(exc)
             _installed.mount_finished(ident, error)
             _take_writes()
+            if transport is not None and transport.finish_exits:
+                # The fake native stack finishes its transitions at once.
+                for op in transaction.ops:
+                    if op.kind == "exit" and op.owner == 1:
+                        _installed.exit_finished(transaction.surface, op.tag)
+                _take_writes()
     finally:
         _mounting = False
 
@@ -210,6 +232,9 @@ def reset_fakes() -> None:
     _transports.clear()
     if _installed is not None:
         _installed.reset()
+    from ..motion.runtime import runtime as motion
+
+    motion.reset()  # the core forgot every program, shared value, and binding
     from . import _loaded_contracts
 
     _loaded_contracts.clear()  # the reset dropped every compiled contract
@@ -233,7 +258,7 @@ class FakeTransport:
         views: Mounted views by tag (flattened views never appear).
         transactions: Every decoded mount transaction.
         commands: ``(tag, name, args)`` tuples in the order the UI thread ran them.
-        writes: ``(tag, prop, value)`` animated writes, in order.
+        writes: Every [`MotionWrite`][pythonnative.bridge.core.MotionWrite], in order.
         calls: ``(module, method, args)`` tuples in call order.
         measured: ``(tag, component)`` pairs the core asked the platform to measure.
     """
@@ -260,7 +285,9 @@ class FakeTransport:
         self.views: Dict[int, FakeNativeView] = {}
         self.transactions: List[MountTransaction] = []
         self.commands: List[Tuple[int, str, Dict[str, Any]]] = []
-        self.writes: List[Tuple[int, str, Any]] = []
+        self.writes: List[MotionWrite] = []
+        self.finish_exits = True
+        """Finish platform-owned exits (leaving screens and modals) as soon as they mount."""
         self.calls: List[Tuple[str, str, Dict[str, Any]]] = []
         self.measured: List[Tuple[int, str]] = []
         self.command_results: Dict[str, Any] = {}
@@ -316,12 +343,25 @@ class FakeTransport:
         _mount_all()
         return result
 
-    def animate(self, surface: int, tag: int, request_json: str) -> str:
-        """Queue an animation request and run it on the fake UI thread."""
-        result = self.core.animate(surface, tag, request_json)
+    def motion(self, surface: int, request_json: str) -> str:
+        """Queue a motion request and apply it on the fake UI thread."""
+        result = self.core.motion(surface, request_json)
         _mount_all()
         return result
 
+    def shared_read(self, ident: int) -> str:
+        """The latest value the fake UI thread published for a shared value, as JSON."""
+        return self.core.shared_read(ident)
+
+    def exit_finished(self, tag: int) -> None:
+        """Finish a platform-owned exit (a leaving screen or modal), as the native stack would."""
+        self.core.exit_finished(self.surface, tag)
+        _take_writes()
+
+    def shared_elements(self, from_screen: int, to_screen: int) -> List[Dict[str, Any]]:
+        """The views the core pairs by ``shared_tag`` between two screens."""
+        return list(json.loads(self.core.shared_elements(self.surface, from_screen, to_screen)))
+
     def measure(self, surface: int, tag: int) -> str:
         """The shadow and window frames of a view."""
         return self.core.measure(surface, tag)
@@ -387,9 +427,20 @@ class FakeTransport:
             child = self._require(op.tag, "insert")
             if child.parent is not None:
                 child.parent.children.remove(child)
-            index = max(0, min(int(op.index), len(parent.children)))
+            # Indices count only the children that aren't animating out.
+            index = len(parent.children)
+            live = 0
+            for position, sibling in enumerate(parent.children):
+                if sibling.exiting is not None:
+                    continue
+                if live == int(op.index):
+                    index = position
+                    break
+                live += 1
             parent.children.insert(index, child)
             child.parent = parent
+        elif op.kind == "exit":
+            self._require(op.tag, "exit").exiting = op.owner
         elif op.kind == "delete":
             deleted = self.views.pop(op.tag, None)
             if deleted is None:
@@ -414,6 +465,26 @@ class FakeTransport:
                 codec.dumps({"call_id": op.call_id, "ok": True, "value": codec.to_jsonable(result)}),
             )
 
+    def _write(self, write: MotionWrite) -> None:
+        self.writes.append(write)
+        if write.kind == "prop":
+            view = self.views.get(write.tag)
+            if view is not None:
+                if write.value is None:
+                    view.animated.pop(write.prop, None)
+                else:
+                    view.animated[write.prop] = write.value
+        elif write.kind == "frame":
+            view = self.views.get(write.tag)
+            if view is not None:
+                view.frame = write.frame
+        elif write.kind == "remove":
+            for tag in write.tags:
+                removed = self.views.pop(tag, None)
+                if removed is not None and removed.parent is not None:
+                    removed.parent.children.remove(removed)
+                    removed.parent = None
+
     def _publish_list(self, tag: int) -> None:
         edits = self.core.list_apply(self.surface, tag)
         if edits is not None: