pythonnative 0.24.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

pythonnative/screen.py

@@ -1587,6 +1587,19 @@ else:
                     return True
                 _log_pn("_request_render: native iOS scheduler unavailable; render remains queued")
                 return True
+            # Defer via the main dispatch queue rather than an NSTimer.
+            # GCD main-queue blocks are serviced in the common run-loop
+            # modes, so they still run while UIKit is in tracking mode
+            # (scrolls, synthesized test touches). A default-mode NSTimer
+            # is starved for the whole gesture, which delayed renders
+            # long enough on slow CI simulators for Maestro asserts to
+            # time out, and let stale flushes land mid-touch.
+            from .runtime import _ensure_libdispatch_loaded, _ios_dispatch_async
+
+            if _ensure_libdispatch_loaded():
+                _ios_dispatch_async(_flush_ios_scheduled_renders)
+                _log_pn("_request_render: deferred iOS render to next main-queue turn")
+                return True
             try:
                 NSTimer = ObjCClass("NSTimer")
                 target = _ensure_ios_render_scheduler_target()
@@ -1719,22 +1732,55 @@ else:
                     raise RuntimeError(
                         "No UINavigationController available; ensure template embeds root in navigation controller"
                     )
-                nav.pushViewController_animated_(next_vc, True)
+                self._run_nav_op(lambda n: n.pushViewController_animated_(next_vc, True))
 
             def _pop(self) -> None:
-                nav = getattr(self.native_instance, "navigationController", None)
-                if nav is not None:
-                    nav.popViewControllerAnimated_(True)
+                self._run_nav_op(lambda n: n.popViewControllerAnimated_(True))
 
             def _reset_to_root(self) -> None:
                 """Pop everything above the root view-controller."""
-                nav = getattr(self.native_instance, "navigationController", None)
-                if nav is not None:
+
+                def op(n: Any) -> None:
                     try:
-                        nav.popToRootViewControllerAnimated_(True)
+                        n.popToRootViewControllerAnimated_(True)
                     except Exception:
                         pass
 
+                self._run_nav_op(op)
+
+            def _run_nav_op(self, op: Any) -> None:
+                """Run ``op(nav)`` unless a stack transition is mid-flight.
+
+                UIKit does not queue navigation calls: a
+                ``pushViewController`` / ``popViewController`` issued
+                while the previous transition is still animating is
+                silently ignored or, worse, misapplies and pops past
+                the intended screen. A fast tap right after a push
+                (easy for a user, common for a UI test on a slow
+                machine) lands exactly in that window. Dropping the
+                operation keeps the stack consistent: the tap simply
+                does nothing, and a retry lands on a settled stack.
+                (Deferring the operation instead was tried and is
+                worse: the user retries, then the deferred operation
+                also fires, popping one screen too many.)
+                """
+                nav = getattr(self.native_instance, "navigationController", None)
+                if nav is None:
+                    return
+                try:
+                    # rubicon resolves ``transitionCoordinator`` as a bound
+                    # method rather than a property on some classes; call
+                    # it to get the actual (possibly nil -> None) value.
+                    coord = nav.transitionCoordinator
+                    if callable(coord):
+                        coord = coord()
+                    if coord is not None:
+                        _log_pn("_run_nav_op: transition in flight; dropping nav op")
+                        return
+                except Exception:
+                    pass
+                op(nav)
+
             def _set_screen_options(self, options: Dict[str, Any]) -> None:
                 """Bind screen options (e.g. title) to the native nav bar.
 

pythonnative/storage.py

@@ -379,7 +379,7 @@ def use_persisted_state(
             )
         ```
     """
-    from .hooks import use_async_effect, use_callback, use_ref, use_state
+    from .hooks import use_callback, use_effect, use_ref, use_state
     from .runtime import run_async
 
     state, set_state = use_state(initial)
@@ -391,7 +391,7 @@ def use_persisted_state(
             set_state(stored)
         loaded.current = True
 
-    use_async_effect(_load, [key])
+    use_effect(_load, [key])
 
     def setter(value_or_updater: Any) -> None:
         def _reducer(current: Any) -> Any:

pythonnative/suspense.py

@@ -0,0 +1,417 @@
+"""Suspense primitives: suspension signals, resources, and lazy loading.
+
+This module implements the machinery behind PythonNative's async
+rendering model:
+
+- ``async def`` components: a component body may be a coroutine. The
+  reconciler drives it synchronously as far as possible (awaits on
+  already-resolved futures complete inline); if it blocks on pending
+  work, the render **suspends** and the nearest
+  [`Suspense`][pythonnative.Suspense] boundary shows its fallback
+  until the coroutine finishes.
+- [`use_resource`][pythonnative.use_resource]: a hook that starts an
+  async fetch and caches it across renders. Reading an unresolved
+  [`Resource`][pythonnative.Resource] suspends the render; awaiting it
+  inside an ``async def`` component does the same thing without the
+  boundary having to re-run anything by hand.
+- [`lazy`][pythonnative.lazy]: code-splitting for components. The
+  loader runs once, and renders suspend until it resolves.
+
+The core building block is [`CoroDriver`][pythonnative.suspense.CoroDriver],
+a miniature task that steps a coroutine **synchronously** until it
+either finishes or blocks on a pending :class:`asyncio.Future`. This is
+what lets an ``async def`` component whose awaits are all cached
+(resolved resources, completed tasks) render in a single synchronous
+pass with zero event-loop round trips, while genuinely pending awaits
+suspend cleanly.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import inspect
+from typing import Any, Callable, Generic, List, Optional, Tuple, TypeVar
+
+T = TypeVar("T")
+
+_UNSET = object()
+
+
+class Suspend(BaseException):
+    """Signal that a render is blocked on pending async work.
+
+    Raised while a component renders, either by
+    [`Resource.read`][pythonnative.suspense.Resource.read] or by an
+    ``async def`` component body blocking on a pending await. The
+    reconciler catches it: the nearest
+    [`Suspense`][pythonnative.Suspense] boundary shows its fallback
+    (initial mounts), or the component keeps its previous content and
+    re-renders when the work finishes (updates).
+
+    Derives from :class:`BaseException` so
+    [`ErrorBoundary`][pythonnative.ErrorBoundary] (which catches
+    :class:`Exception`) never mistakes a suspension for a crash.
+
+    Attributes:
+        waitable: The pending work; exposes ``done()`` and
+            ``add_done_callback(cb)``.
+        hook_state: The suspended component's hook state, carried so
+            a Suspense boundary can preserve it across retries (its
+            cached resources survive, so the retry doesn't refetch).
+        key: ``(component identity, element key)`` used to re-match
+            ``hook_state`` on retry.
+        label: Component name for diagnostics.
+    """
+
+    def __init__(self, waitable: Any, hook_state: Any = None, label: str = "") -> None:
+        super().__init__(label or "render suspended")
+        self.waitable = waitable
+        self.hook_state = hook_state
+        self.key: Optional[Tuple[int, Any]] = None
+        self.label = label
+
+
+class CoroDriver:
+    """Drive a coroutine synchronously until it blocks on pending work.
+
+    A miniature :class:`asyncio.Task`: it steps the coroutine with
+    ``send()``, resolving awaits on already-done futures inline. When
+    the coroutine blocks on a *pending* future, the driver parks and
+    resumes from that future's done callback (on the framework loop's
+    thread). Each step runs inside the :mod:`contextvars` context
+    captured at creation, so hooks called after an ``await`` still see
+    the owning component's hook state.
+
+    Attributes:
+        done: Whether the coroutine finished (returned, raised, or was
+            cancelled).
+    """
+
+    __slots__ = (
+        "_coro",
+        "_context",
+        "done",
+        "_cancelled",
+        "_result",
+        "_error",
+        "_callbacks",
+        "_waiting_on",
+        "_stepping",
+    )
+
+    def __init__(self, coro: Any, context: Optional[contextvars.Context] = None) -> None:
+        self._coro = coro
+        self._context = context if context is not None else contextvars.copy_context()
+        self.done = False
+        self._cancelled = False
+        self._result: Any = _UNSET
+        self._error: Optional[BaseException] = None
+        self._callbacks: List[Callable[["CoroDriver"], None]] = []
+        self._waiting_on: Optional[Any] = None
+        self._stepping = False
+
+    # -- inspection ------------------------------------------------------
+
+    def cancelled(self) -> bool:
+        """Whether the driver was cancelled before finishing normally."""
+        return self._cancelled
+
+    def result(self) -> Any:
+        """Return the coroutine's return value (raises if not done or failed)."""
+        if not self.done:
+            raise RuntimeError("CoroDriver is not done")
+        if self._error is not None:
+            raise self._error
+        return self._result
+
+    def exception(self) -> Optional[BaseException]:
+        """Return the coroutine's exception, or ``None``."""
+        if not self.done:
+            raise RuntimeError("CoroDriver is not done")
+        return self._error
+
+    def add_done_callback(self, callback: Callable[["CoroDriver"], None]) -> None:
+        """Invoke ``callback(self)`` when the coroutine finishes.
+
+        Fires immediately when already done. Callbacks run on whatever
+        thread finished the coroutine (the framework loop's thread for
+        suspended coroutines).
+        """
+        if self.done:
+            callback(self)
+            return
+        self._callbacks.append(callback)
+
+    # -- driving ---------------------------------------------------------
+
+    def start(self) -> None:
+        """Run the coroutine as far as it can go without blocking."""
+        self._step(("send", None))
+
+    def cancel(self) -> bool:
+        """Throw :class:`asyncio.CancelledError` into the coroutine.
+
+        Returns:
+            ``False`` when the coroutine had already finished,
+            ``True`` otherwise.
+        """
+        if self.done:
+            return False
+        waiting = self._waiting_on
+        self._waiting_on = None
+        if waiting is not None:
+            try:
+                waiting.remove_done_callback(self._resume)
+            except Exception:
+                pass
+        self._cancelled = True
+        self._step(("throw", asyncio.CancelledError()))
+        return True
+
+    def _resume(self, _fut: Any) -> None:
+        self._waiting_on = None
+        self._step(("send", None))
+
+    def _step(self, action: Tuple[str, Any]) -> None:
+        if self.done or self._stepping:
+            return
+        self._stepping = True
+        # When a step runs outside a loop iteration (a synchronous
+        # render), mark the framework loop as the running loop for the
+        # duration, exactly as asyncio.Task steps do. Without this,
+        # anything the coroutine calls that uses
+        # ``asyncio.get_running_loop()`` internally (``asyncio.sleep``,
+        # ``asyncio.create_task``, ...) raises "no running event loop".
+        from . import runtime
+
+        events = asyncio.events
+        installed_loop = None
+        if events._get_running_loop() is None:
+            installed_loop = runtime.get_loop()
+            events._set_running_loop(installed_loop)
+        try:
+            self._context.run(self._advance, action)
+        finally:
+            if installed_loop is not None:
+                events._set_running_loop(None)
+            self._stepping = False
+
+    def _advance(self, action: Tuple[str, Any]) -> None:
+        kind, value = action
+        while True:
+            try:
+                if kind == "throw":
+                    yielded = self._coro.throw(value)
+                else:
+                    yielded = self._coro.send(value)
+            except StopIteration as stop:
+                self._finish(stop.value, None)
+                return
+            except asyncio.CancelledError as exc:
+                self._cancelled = True
+                self._finish(None, exc)
+                return
+            except BaseException as exc:
+                self._finish(None, exc)
+                return
+
+            kind, value = "send", None
+            if yielded is None:
+                # ``await asyncio.sleep(0)`` and bare yields: resume on
+                # the next loop tick to preserve cooperative yielding.
+                from . import runtime
+
+                runtime.get_loop().call_soon(self._resume, None)
+                return
+            if isinstance(yielded, asyncio.Future):
+                # Mirror asyncio.Task's handshake with Future.__await__.
+                try:
+                    yielded._asyncio_future_blocking = False
+                except AttributeError:
+                    pass
+                if yielded.done():
+                    continue
+                self._waiting_on = yielded
+                yielded.add_done_callback(self._resume)
+                return
+            self._finish(
+                None,
+                RuntimeError(
+                    f"async component awaited an unsupported object: {yielded!r}. "
+                    "Await asyncio futures, tasks, or PythonNative awaitables."
+                ),
+            )
+            return
+
+    def _finish(self, result: Any, error: Optional[BaseException]) -> None:
+        self.done = True
+        self._result = result
+        self._error = error
+        self._waiting_on = None
+        callbacks = self._callbacks
+        self._callbacks = []
+        for callback in callbacks:
+            try:
+                callback(self)
+            except Exception as exc:
+                print(f"[pn.suspense] done callback raised: {exc!r}")
+
+
+class Resource(Generic[T]):
+    """A cached async value with Suspense integration.
+
+    Returned by [`use_resource`][pythonnative.use_resource]. A resource
+    starts fetching as soon as the hook runs and remembers its result
+    across renders (until its dependencies change), so re-renders never
+    refetch.
+
+    Two ways to consume it:
+
+    - ``resource.read()`` in a regular component: returns the value
+      when ready, re-raises the fetcher's error if it failed, and
+      **suspends the render** while pending.
+    - ``await resource`` in an ``async def`` component: same
+      semantics, expressed as a plain await.
+    """
+
+    __slots__ = ("_driver",)
+
+    def __init__(self, driver: CoroDriver) -> None:
+        self._driver = driver
+
+    @property
+    def ready(self) -> bool:
+        """Whether the fetch has finished (successfully or not)."""
+        return self._driver.done
+
+    def read(self) -> T:
+        """Return the fetched value, or suspend the render while pending.
+
+        Raises:
+            Suspend: While the fetch is still in flight (caught by the
+                reconciler, never by user code).
+            BaseException: Whatever the fetcher raised, re-raised so an
+                enclosing [`ErrorBoundary`][pythonnative.ErrorBoundary]
+                can catch it.
+        """
+        driver = self._driver
+        if driver.done:
+            return driver.result()
+        raise Suspend(driver, label="Resource.read")
+
+    def __await__(self) -> Any:
+        driver = self._driver
+        if driver.done:
+
+            def _done() -> Any:
+                return driver.result()
+                yield  # pragma: no cover - marks this as a generator
+
+            return _done()
+        from . import runtime
+
+        future = runtime.create_future()
+
+        def _transfer(d: CoroDriver) -> None:
+            error = d.exception() if not d.cancelled() else asyncio.CancelledError()
+            if error is not None:
+                runtime.reject_future(future, error)
+            else:
+                runtime.resolve_future(future, d.result())
+
+        driver.add_done_callback(_transfer)
+        return future.__await__()
+
+    def cancel(self) -> None:
+        """Cancel the in-flight fetch (no-op when already done)."""
+        self._driver.cancel()
+
+
+def start_resource(fetcher: Callable[[], Any]) -> Resource[Any]:
+    """Start ``fetcher`` immediately and wrap it in a [`Resource`][pythonnative.Resource].
+
+    The fetcher may be an ``async def`` (typical) or a plain function;
+    synchronous results resolve the resource immediately, so reading
+    it never suspends.
+
+    This is the non-hook constructor used for module-level resources
+    (preloading data before a screen mounts) and by
+    [`lazy`][pythonnative.lazy]. Inside components, prefer
+    [`use_resource`][pythonnative.use_resource], which caches per
+    component instance and re-fetches when dependencies change.
+    """
+
+    async def _run() -> Any:
+        value = fetcher()
+        if inspect.isawaitable(value):
+            return await value
+        return value
+
+    driver = CoroDriver(_run())
+    driver.start()
+    return Resource(driver)
+
+
+def lazy(loader: Callable[[], Any]) -> Callable[..., Any]:
+    """Define a component that loads its implementation on first render.
+
+    ``loader`` runs once, the first time the returned component
+    renders; until it resolves, renders suspend (so wrap usages in a
+    [`Suspense`][pythonnative.Suspense] boundary to show a loading
+    state). The loaded value must be a component (a ``@component``
+    function or any element factory).
+
+    Args:
+        loader: A zero-arg callable returning the component, or an
+            ``async def`` resolving to it. Synchronous loaders (a
+            deferred ``import``) resolve immediately and never
+            suspend.
+
+    Returns:
+        A component. Props (and children) pass through to the loaded
+        component unchanged.
+
+    Example:
+        ```python
+        import pythonnative as pn
+
+        Chart = pn.lazy(lambda: __import__("app.chart", fromlist=["Chart"]).Chart)
+
+        @pn.component
+        def Dashboard():
+            return pn.Suspense(
+                Chart(points=[1, 2, 3]),
+                fallback=pn.ActivityIndicator(),
+            )
+        ```
+    """
+    from .hooks import component
+
+    state: dict = {}
+
+    @component
+    def Lazy(**props: Any) -> Any:
+        resource = state.get("resource")
+        if resource is None:
+            resource = start_resource(loader)
+            state["resource"] = resource
+        loaded = resource.read()
+        children = props.pop("children", None)
+        if children:
+            return loaded(*children, **props)
+        return loaded(**props)
+
+    Lazy.__name__ = getattr(loader, "__name__", "Lazy")
+    if Lazy.__name__ == "<lambda>":
+        Lazy.__name__ = "Lazy"
+    return Lazy
+
+
+__all__ = [
+    "CoroDriver",
+    "Resource",
+    "Suspend",
+    "lazy",
+    "start_resource",
+]

{pythonnative-0.24.0.dist-info → pythonnative-0.25.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.24.0
+Version: 0.25.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License
@@ -105,6 +105,7 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 - **Rich component library:** 25+ built-in components backed by real native widgets: `TextInput`, `Image` / `ImageBackground`, `ScrollView`, `FlatList` / `SectionList`, `Modal`, `Pressable` / `TouchableOpacity`, `Switch` / `Checkbox`, `Slider`, `SegmentedControl`, `Picker`, `DatePicker`, `ProgressBar` / `ActivityIndicator`, `WebView`, and more.
 - **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.
 - **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.

{pythonnative-0.24.0.dist-info → pythonnative-0.25.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
-pythonnative/__init__.py,sha256=HcUCPSMZBt7N1-AFt4u6doqhgt_VOgImWEASJk5Tj6A,8394
+pythonnative/__init__.py,sha256=4WYUg8cAV8_JboVBvwc0SR5sRvY4SW7CR4qKrflOBm0,8680
 pythonnative/_ios_log.py,sha256=Oi7V28VxcVoZyrpAirvLeEmUW18McqnU87V4d37Zzlw,2582
 pythonnative/alerts.py,sha256=mIANysFlaHwL5EqKnvNcyiJN9rGiZi9XDrD9Jpz1RFM,9340
-pythonnative/animated.py,sha256=2t6thUzmmapccP6ziW-x2tr8A2LCrWQoF8KqoETdSDY,36226
+pythonnative/animated.py,sha256=OzDqG9ijkxF0rfU0glmgmGikbVB1s5ExoWndy74EhBw,36214
 pythonnative/appearance.py,sha256=vMkDRIz9ptaprMmlPmiYJLVwrDslfnc1bhwyE27M2ZI,3891
-pythonnative/components.py,sha256=61DKYxdcfaw1B4LqS5ho0aUksxjkA2zq4BB1cJiQHzA,106286
+pythonnative/components.py,sha256=xmJFHw88xPzUQQGeVVhujrIiNLQiQTBZZkPxOD8iWoA,108436
 pythonnative/diagnostics.py,sha256=F6Ym163wSZI93j_ScwRWULIuxRxQ39f5lqvXRDP93po,7078
 pythonnative/element.py,sha256=jbCMPiVq4oRgbSAbKdltBJ1BU6Aom1qKoc6-FsbpJ74,2902
 pythonnative/events.py,sha256=EFYz8HxVOTA3soAe0Z9P2gZN9ShLjXhKH7I34DmnNbM,7895
 pythonnative/gestures.py,sha256=6qe_s3Cv2M5_V-_PgAQ5y9QbYV812B0xVmh8dRDHYMY,29940
-pythonnative/hooks.py,sha256=iOngNAtCeQPwdL0zwvgJ1TOKSarObVSG_zIhSAyKhPo,54439
+pythonnative/hooks.py,sha256=tpMHxESLndaI_PXHNOcV_4B_u7ZzijQtSXH8_RU5kko,65422
 pythonnative/hot_reload.py,sha256=2HI6u-fc4JRudc35BAe8RXmPIXLWh1imoH4fMVqu_Ks,25502
 pythonnative/images.py,sha256=JFjBJdZzZoQmAOfQ7QHqi7dYJ75XTs3u2lweQHGbdPc,6466
 pythonnative/layout.py,sha256=Ck_FCLSk0g4hdOzHo0c50cbvLe8Q8caQAxywXgnFhKM,49077
@@ -18,11 +18,12 @@ pythonnative/net.py,sha256=8D7EyEC8-JkYxlrtVfTDApOGzzdcA4P4kaCdYBBZI8E,8082
 pythonnative/platform.py,sha256=WtjxR04CqVhSnjJu-3upk8bwXYaSWr2N0MOVoNov-h0,4994
 pythonnative/platform_metrics.py,sha256=1r1kMbgS9LcVTbdpP5qRD4oHEvw70te5BXEyd_16Ihc,8961
 pythonnative/preview.py,sha256=RoZv1s142GWj9xpg9v5Kh-0YuuhpEfwwb_JdnzboRLw,19355
-pythonnative/reconciler.py,sha256=_3-TZ7cYFvcF9Jeu3_lHa33qwfXy4OkWAVfSaYpRpNY,74426
-pythonnative/runtime.py,sha256=Ij3xxr_RyWESX7jP7b-RpsYjqjsJi1OpoV3WL3WTBWU,18245
-pythonnative/screen.py,sha256=_ylaGFviZGwllEd1akQRNJIuXIsEQf_81QkFkjblu7k,80851
-pythonnative/storage.py,sha256=3brJoo0X6YuxXiAv67fHwDotPRazVP3l8dxiRiEnNEo,11995
+pythonnative/reconciler.py,sha256=6tzn5CsGvGypTnQ7sglEimfrdl7K3dP9W464n9naWZU,96412
+pythonnative/runtime.py,sha256=m4MllJcApoor822LrceIWNLa2YPbd5lgeijQd3yqp0c,25701
+pythonnative/screen.py,sha256=Z0jYl_ZfZkde_Kel2m7kGMNEQesHQudshvI5WmXLvhU,83246
+pythonnative/storage.py,sha256=DNhRJWkT_iwb8lb-8YgTx2P_BHnYkOePLeOPPxcvREc,11983
 pythonnative/style.py,sha256=-XP1vbqiTEkQraFF0JknZLHIzVsou-GUhrKz5zQ7vVk,20030
+pythonnative/suspense.py,sha256=IxWGXFP3Odriy0uQe9zhrNrObdKer0_WT6v9Vi8Vatg,14665
 pythonnative/utils.py,sha256=-hwe_YS19ebpjeygdl3dGeVsYzO4G74rYD53svSi0rI,7593
 pythonnative/virtual_rows.py,sha256=4YK3CeZobW-6F6GCXzGNFfmOaAiigmH4HXtqjYDRbyU,5056
 pythonnative/cli/__init__.py,sha256=NM1psvKe8jT0vzp8Ak4MMoygZz4P_msk5g-YEsY8xLk,232
@@ -38,15 +39,15 @@ pythonnative/native_modules/haptics.py,sha256=YklgquXUFyQS2a6AizflJj-dM2LHyS86Rd
 pythonnative/native_modules/linking.py,sha256=dny2geVaO975JYxoc7DD_PvGs2FyZ1QvZ7JySxbv5dY,5044
 pythonnative/native_modules/location.py,sha256=K_zXUP6XWqJt3qqUMkop_TdMn-yOQB_2TZ18eEQ9Rdc,7606
 pythonnative/native_modules/net_info.py,sha256=QGoi4xZqk9IMyKR9m-delWNRDjEgYRDmxK4lGhZpLoE,5104
-pythonnative/native_modules/notifications.py,sha256=WVtzdimc_aGfnxU6syCFPkjHF9YRRc97UVK3--TBwoU,7115
-pythonnative/native_modules/permissions.py,sha256=ABIWiCuLIiZJmfA-B7dnw56_Iz7ApGzdtLAs6X694QU,6704
+pythonnative/native_modules/notifications.py,sha256=w2_ChU8Ae-QGnijIxtCOGbBFxR68GlMdDP-LMYmiTyw,8448
+pythonnative/native_modules/permissions.py,sha256=m2kPUiKYZ3ws1bRY4DGgAzmRCzBnu-zQ905z8A6C6UA,7736
 pythonnative/native_modules/secure_store.py,sha256=PsnUwHzUPt-CzCAwM6BhidOBi9yofRD2uNtQIqAGofU,5953
 pythonnative/native_modules/share.py,sha256=B9ovknmnjeQvGQ8MQ14Hmq6E1x-JA469APMburJ0KUg,4727
 pythonnative/native_views/__init__.py,sha256=93v7pt0_7f8BWqOiwSvlq20F1oJLfCnmQBvLlCDA-Xk,15340
-pythonnative/native_views/android.py,sha256=YKokykZUkMT7N2f2Ug0uShquCdwI5joYmdVp5DzATFA,133786
+pythonnative/native_views/android.py,sha256=vAS1BIZG_gX0nuI4ibEum2XNJc4bv3_uGiHj4dsc_PY,134114
 pythonnative/native_views/base.py,sha256=NFDlEIoKCINzcVkf2uobT9TgujPb1RClLS3TzwH72MY,9668
 pythonnative/native_views/desktop.py,sha256=ZZZ1aw9iRswAfkVoYMUsFz2ztppRgFpMxxwrBkNS7lw,61192
-pythonnative/native_views/ios.py,sha256=zLyaCGFSpcwgtpZd2daCv7TPjCBNPL-F23byLOflnYA,178536
+pythonnative/native_views/ios.py,sha256=1QhEx9FoHkar3DyuItVWGwzO3oEzrW-TGTPyxtsQDtI,179200
 pythonnative/project/__init__.py,sha256=kAhWLONs53H1L7xVtczLmzYcQSOOkdRZTAJnIMhpBts,2064
 pythonnative/project/android.py,sha256=SX0uu4-tz4WdYAf9sbycQPSmoQ8fbtAADeUWk9G8ybM,19127
 pythonnative/project/builder.py,sha256=DokY-YidsDeWYgaixrpD3Kzp7_XudibltI8X_WdBIcE,19096
@@ -112,9 +113,9 @@ pythonnative/templates/ios_template/ios_template.xcodeproj/project.xcworkspace/x
 pythonnative/templates/ios_template/ios_templateTests/ios_templateTests.swift,sha256=YnwzZx7yXB13xKAXEGNgz17VuhWeqkHTRTtBJ2Vu3_E,1238
 pythonnative/templates/ios_template/ios_templateUITests/ios_templateUITests.swift,sha256=HLRr3cmouRqQeXG13WrZ2XSAmgMgCsNXfZpbwkxeFcs,1385
 pythonnative/templates/ios_template/ios_templateUITests/ios_templateUITestsLaunchTests.swift,sha256=f5JrG0uVtLMeJQy26Yyz7Om-JUkT220osqcbeIVkj2g,815
-pythonnative-0.24.0.dist-info/licenses/LICENSE,sha256=A69iG7TIAe6KkGQf6xoVHkc5JSZtOr5eRSvC5iuivnI,1067
-pythonnative-0.24.0.dist-info/METADATA,sha256=ad8csbo8lKOGtl9VfjTwTv4k5rx8E8UoKVHKbgPpmGE,11050
-pythonnative-0.24.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-pythonnative-0.24.0.dist-info/entry_points.txt,sha256=iUtDawWSAJAEyWTycpZxDuYz73ol31butpzDIEAgPO0,48
-pythonnative-0.24.0.dist-info/top_level.txt,sha256=kT4SEATY2ywzrZ2Pgea6_zxyym44Q_PbOsUoOYjJLFE,13
-pythonnative-0.24.0.dist-info/RECORD,,
+pythonnative-0.25.0.dist-info/licenses/LICENSE,sha256=A69iG7TIAe6KkGQf6xoVHkc5JSZtOr5eRSvC5iuivnI,1067
+pythonnative-0.25.0.dist-info/METADATA,sha256=JiIpbQJggQXhQhjk_ky3Rn-W1EhWc3yP30-6rvqpk2U,11541
+pythonnative-0.25.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pythonnative-0.25.0.dist-info/entry_points.txt,sha256=iUtDawWSAJAEyWTycpZxDuYz73ol31butpzDIEAgPO0,48
+pythonnative-0.25.0.dist-info/top_level.txt,sha256=kT4SEATY2ywzrZ2Pgea6_zxyym44Q_PbOsUoOYjJLFE,13
+pythonnative-0.25.0.dist-info/RECORD,,

{pythonnative-0.24.0.dist-info → pythonnative-0.25.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (83.0.0)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any