pythonnative 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

pythonnative/__init__.py

@@ -41,7 +41,7 @@ Example:
     ```
 """
 
-__version__ = "0.13.0"
+__version__ = "0.14.0"
 
 from .alerts import Alert
 from .animated import Animated, AnimatedValue

pythonnative/hot_reload.py

@@ -196,10 +196,19 @@ class ModuleReloader:
     """Reload changed Python modules on device and trigger a re-render.
 
     Designed to be invoked from device-side glue when a hot-reload
-    push completes. The class itself holds no state; all methods are
-    static.
+    push completes. All public methods are static; the class holds a
+    single piece of process-wide state — the manifest version that
+    has most recently been applied to ``sys.modules`` — so that
+    multiple screen hosts polling the same manifest do not each
+    re-execute the user-app modules. The first host to see a new
+    version pays the ``reload_modules`` cost; subsequent hosts on the
+    same version refresh only their own reconciler tree against the
+    already-fresh modules.
     """
 
+    _last_reloaded_version: Optional[str] = None
+    _reload_lock = threading.Lock()
+
     @staticmethod
     def reload_module(module_name: str) -> bool:
         """Reload a single module by its dotted name.
@@ -254,6 +263,139 @@ class ModuleReloader:
                 reloaded.append(module_name)
         return reloaded
 
+    @staticmethod
+    def reload_modules_for_version(
+        module_names: Sequence[str],
+        version: Optional[str],
+    ) -> List[str]:
+        """Reload ``module_names`` for ``version``, deduping across hosts.
+
+        Each native screen host on iOS / Android runs its own poll
+        loop and would otherwise call
+        [`reload_modules`][pythonnative.hot_reload.ModuleReloader.reload_modules]
+        independently for the same manifest version. That re-executes
+        every user-app module N times (once per host) per file change,
+        producing N different generations of the same function objects
+        in ``sys.modules`` and leaving each host's reconciler tree
+        pointing at a different generation. Beyond the wasted work,
+        the inconsistent state has been observed to crash UIKit on iOS
+        with ``CALayerInvalidGeometry`` (NaN values fed into ``setFrame_:``
+        during the interleaved renders).
+
+        This helper serializes on
+        [`_reload_lock`][pythonnative.hot_reload.ModuleReloader] and uses
+        [`_last_reloaded_version`][pythonnative.hot_reload.ModuleReloader]
+        to ensure only the *first* host to see a given ``version``
+        actually re-executes the modules. Subsequent hosts on the same
+        version get back the already-fresh entries from ``sys.modules``
+        so their own
+        [`refresh_in_place`][pythonnative.hot_reload.ModuleReloader.refresh_in_place]
+        pass can still rewrite their tree against the same generation.
+
+        Args:
+            module_names: Dotted module names to reload.
+            version: Manifest version this reload is processing. When
+                ``None`` (e.g. tests calling reload directly) the call
+                falls back to the unconditional
+                [`reload_modules`][pythonnative.hot_reload.ModuleReloader.reload_modules]
+                behavior.
+
+        Returns:
+            The list of module names that are currently fresh in
+            ``sys.modules`` — either freshly reloaded by this call, or
+            already reloaded by an earlier host for the same version.
+        """
+        with ModuleReloader._reload_lock:
+            if version is not None and version == ModuleReloader._last_reloaded_version:
+                return [name for name in module_names if name in sys.modules]
+            reloaded = ModuleReloader.reload_modules(module_names)
+            if reloaded and version is not None:
+                ModuleReloader._last_reloaded_version = version
+            return reloaded
+
+    @staticmethod
+    def expand_reload_targets(changed_modules: Sequence[str], component_path: str) -> List[str]:
+        """Expand a manifest of changed modules into the full reload order.
+
+        When a user edits ``app/screens/home.py``, only that file is in
+        the manifest. But the entry-point module ``app.main`` has
+        bindings like ``from app.screens.home import HomeScreen`` that
+        need to be re-evaluated against the freshly-loaded
+        ``app.screens.home``; likewise other user-app modules may carry
+        transitive bindings (e.g. through a shared ``app/theme.py``)
+        that go stale if only the changed file is reloaded.
+
+        This helper computes the full ordered reload list:
+
+        1. Explicitly changed modules first (in the order given), so
+           their fresh source replaces the cached version in
+           ``sys.modules`` before any dependent modules re-execute.
+        2. All other currently-imported modules under the entry-point's
+           top-level package, deepest first. The depth heuristic biases
+           toward leaves so re-executing a screen file picks up the
+           newest shared utilities before the file that imports it does.
+        3. The entry-point module itself, last, so its
+           ``from ... import`` bindings rebind against everything that
+           was refreshed in steps 1 and 2.
+
+        Modules outside the entry-point's top-level package
+        (``pythonnative.*``, stdlib, third-party) are never included;
+        framework code is not reloaded.
+
+        Args:
+            changed_modules: Modules reported as changed by the host
+                file-watcher (already in dotted form).
+            component_path: The host's entry-point identifier, either a
+                module path (``"app.main"``) or a dotted attribute path
+                (``"app.main.RootScreen"``).
+
+        Returns:
+            The ordered list of modules to feed to
+            [`reload_modules`][pythonnative.hot_reload.ModuleReloader.reload_modules].
+        """
+        entry_module: Optional[str] = None
+        if component_path in sys.modules:
+            entry_module = component_path
+        elif "." in component_path:
+            parent = component_path.rsplit(".", 1)[0]
+            if parent in sys.modules:
+                entry_module = parent
+
+        app_prefix: Optional[str] = None
+        if entry_module:
+            app_prefix = entry_module.split(".")[0]
+        else:
+            for m in changed_modules:
+                if m:
+                    app_prefix = m.split(".")[0]
+                    break
+
+        app_modules: Set[str] = set()
+        if app_prefix:
+            for name in list(sys.modules):
+                if name == app_prefix or name.startswith(app_prefix + "."):
+                    app_modules.add(name)
+
+        ordered: List[str] = []
+        seen: Set[str] = set()
+        for m in changed_modules:
+            if m and m not in seen:
+                ordered.append(m)
+                seen.add(m)
+
+        others = [m for m in app_modules if m not in seen and m != entry_module]
+        others.sort(key=lambda m: (-m.count("."), m))
+        for m in others:
+            ordered.append(m)
+            seen.add(m)
+
+        if entry_module:
+            if entry_module in seen:
+                ordered.remove(entry_module)
+            ordered.append(entry_module)
+
+        return ordered
+
     @staticmethod
     def file_to_module(file_path: str, base_dir: str = "") -> Optional[str]:
         """Convert a file path to a dotted module name.
@@ -491,5 +633,13 @@ class ModuleReloader:
             files = manifest.get("files", [])
             modules = ModuleReloader.modules_from_files(files if isinstance(files, list) else [])
 
-        ModuleReloader.reload_screen(screen_instance, [str(module) for module in modules])
+        # Stash the version on the host so `_reload_host` can dedupe
+        # `reload_modules` across multiple hosts polling the same
+        # manifest. See `reload_modules_for_version`.
+        previous_pending = getattr(screen_instance, "_hot_reload_pending_version", None)
+        try:
+            screen_instance._hot_reload_pending_version = version
+            ModuleReloader.reload_screen(screen_instance, [str(module) for module in modules])
+        finally:
+            screen_instance._hot_reload_pending_version = previous_pending
         return version

pythonnative/native_views/__init__.py

@@ -23,10 +23,67 @@ A mock registry can be installed via
 reconciler with no real native views.
 """
 
+import math
+import sys
+import threading
+import time
 from typing import Any, Dict, Optional, Tuple
 
 from .base import ViewHandler
 
+# ======================================================================
+# Tripwire log rate limiter
+# ======================================================================
+#
+# Defensive NaN/Inf guards in ``set_frame`` and ``_apply_transform`` log
+# a single line per occurrence. That's fine for one-off events, but
+# ``Animated.View`` drives transforms at ~60 Hz; once an
+# ``Animated.Value`` enters a stuck NaN state (e.g., a spring tick
+# corrupted across a Fast Refresh), the tripwire would otherwise emit
+# thousands of identical lines per second and drown the dev console.
+#
+# We instead log the first occurrence immediately, then suppress
+# further messages with the same ``label`` for
+# ``_TRIPWIRE_RATE_LIMIT_S`` seconds, and append a
+# ``(+N similar in last Xs)`` suffix to the next message that escapes
+# the window. The first sample plus a count is enough to diagnose; the
+# bounded log keeps the dev console usable.
+
+_TRIPWIRE_RATE_LIMIT_S: float = 1.0
+_TRIPWIRE_LOG_LOCK = threading.Lock()
+_TRIPWIRE_LAST_LOG_TIME: Dict[str, float] = {}
+_TRIPWIRE_SUPPRESSED_COUNT: Dict[str, int] = {}
+
+
+def _tripwire_log(label: str, message: str) -> None:
+    """Emit ``message`` to stderr, rate-limited per ``label``.
+
+    The first call for a given ``label`` always emits. Calls within
+    ``_TRIPWIRE_RATE_LIMIT_S`` seconds are silently counted. The next
+    call after the window appends ``(+N similar in last Xs)`` and
+    resets the counter.
+    """
+    now = time.monotonic()
+    write = False
+    suppressed = 0
+    with _TRIPWIRE_LOG_LOCK:
+        last = _TRIPWIRE_LAST_LOG_TIME.get(label)
+        if last is None or now - last >= _TRIPWIRE_RATE_LIMIT_S:
+            write = True
+            suppressed = _TRIPWIRE_SUPPRESSED_COUNT.get(label, 0)
+            _TRIPWIRE_SUPPRESSED_COUNT[label] = 0
+            _TRIPWIRE_LAST_LOG_TIME[label] = now
+        else:
+            _TRIPWIRE_SUPPRESSED_COUNT[label] = _TRIPWIRE_SUPPRESSED_COUNT.get(label, 0) + 1
+    if not write:
+        return
+    if suppressed > 0:
+        message = f"{message} (+{suppressed} similar in last {_TRIPWIRE_RATE_LIMIT_S:g}s)"
+    try:
+        print(message, file=sys.stderr, flush=True)
+    except Exception:
+        pass
+
 
 class NativeViewRegistry:
     """Map element type names to platform-specific view handlers.
@@ -136,6 +193,21 @@ class NativeViewRegistry:
         coordinates computed by ``pythonnative.layout`` in points
         relative to the parent's content origin.
         """
+        # Tripwire: log non-finite layout values so we can diagnose
+        # crashes like iOS `CALayerInvalidGeometry` without losing the
+        # repro. Handlers are responsible for clamping before applying.
+        # Rate-limited via ``_tripwire_log`` to avoid 60 Hz floods when
+        # an animated value is stuck at NaN.
+        try:
+            finite = math.isfinite(x) and math.isfinite(y) and math.isfinite(width) and math.isfinite(height)
+        except (TypeError, ValueError):
+            finite = False
+        if not finite:
+            _tripwire_log(
+                "set_frame:nan",
+                f"[set_frame:nan] type={type_name!r} " f"x={x!r} y={y!r} w={width!r} h={height!r}",
+            )
+
         handler = self._handlers.get(type_name)
         if handler is not None:
             handler.set_frame(native_view, x, y, width, height)

pythonnative/native_views/android.py

@@ -1116,10 +1116,41 @@ class TabBarHandler(AndroidViewHandler):
             menu.clear()
             for i, item in enumerate(items):
                 title = item.get("title", item.get("name", ""))
-                menu.add(0, i, i, str(title))
+                menu_item = menu.add(0, i, i, str(title))
+                res_id = self._resolve_icon(item.get("icon"))
+                if res_id:
+                    try:
+                        menu_item.setIcon(res_id)
+                    except Exception:
+                        pass
         except Exception:
             pass
 
+    def _resolve_icon(self, icon: Any) -> int:
+        """Resolve a tab icon spec to an `android.R.drawable.*` res id.
+
+        Accepts a bare string (treated as the drawable's field name on
+        ``android.R.drawable``) or a dict of the form
+        ``{"ios": "...", "android": "ic_menu_home"}``. Returns ``0``
+        when the icon can't be resolved, which the caller treats as
+        "no icon".
+        """
+        if icon is None:
+            return 0
+        name: Any = None
+        if isinstance(icon, str):
+            name = icon
+        elif isinstance(icon, dict):
+            name = icon.get("android")
+        if not name:
+            return 0
+        try:
+            RDrawable = jclass("android.R$drawable")
+            res_id = getattr(RDrawable, str(name), 0)
+            return int(res_id) if res_id else 0
+        except Exception:
+            return 0
+
     def _set_active(self, bnv: Any, active: Any, items: list) -> None:
         if active and items:
             for i, item in enumerate(items):

pythonnative/native_views/ios.py

@@ -28,8 +28,28 @@ from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from rubicon.objc import SEL, ObjCClass, objc_method
 
+from . import _tripwire_log
 from .base import ViewHandler, _safe_max, parse_color_int
 
+
+def _safe_finite(value: Any, default: float = 0.0) -> float:
+    """Coerce ``value`` to a finite float, falling back to ``default``.
+
+    Used as a defensive guard around every call into UIKit that takes a
+    geometry value. Without this, a single NaN or inf produced upstream
+    (layout edge case, stale prop during a reload, etc.) crashes the
+    process via `CALayerInvalidGeometry`. Clamping to ``default``
+    converts that into a recoverable visual glitch and lets the
+    `[set_frame:nan]` / `[set_transform:nan]` tripwire logs surface
+    where the bad value came from.
+    """
+    try:
+        f = float(value)
+    except (TypeError, ValueError):
+        return default
+    return f if math.isfinite(f) else default
+
+
 NSObject = ObjCClass("NSObject")
 UIColor = ObjCClass("UIColor")
 UIFont = ObjCClass("UIFont")
@@ -350,8 +370,32 @@ def _apply_transform(view: Any, props: Dict[str, Any]) -> None:
         return
     try:
         transform = _make_transform(spec)
+        a = float(transform.a)
+        b = float(transform.b)
+        c = float(transform.c)
+        d = float(transform.d)
+        tx = float(transform.tx)
+        ty = float(transform.ty)
+        if not (
+            math.isfinite(a)
+            and math.isfinite(b)
+            and math.isfinite(c)
+            and math.isfinite(d)
+            and math.isfinite(tx)
+            and math.isfinite(ty)
+        ):
+            # Tripwire: a NaN/inf transform crashes UIKit. Log
+            # (rate-limited to avoid 60 Hz spam from stuck Animated
+            # values) and fall back to identity so the app keeps
+            # running.
+            _tripwire_log(
+                "set_transform:nan",
+                f"[set_transform:nan] spec={spec!r} -> " f"(a={a!r}, b={b!r}, c={c!r}, d={d!r}, tx={tx!r}, ty={ty!r})",
+            )
+            view.setTransform_((1.0, 0.0, 0.0, 1.0, 0.0, 0.0))
+            return
         # rubicon-objc accepts the C struct as a tuple of its fields.
-        view.setTransform_((transform.a, transform.b, transform.c, transform.d, transform.tx, transform.ty))
+        view.setTransform_((a, b, c, d, tx, ty))
     except Exception:
         pass
 
@@ -450,10 +494,10 @@ class IOSViewHandler(ViewHandler):
         if native_view is None:
             return
         try:
-            frame_x = float(x)
-            frame_y = float(y)
-            frame_w = float(max(0.0, width))
-            frame_h = float(max(0.0, height))
+            frame_x = _safe_finite(x, 0.0)
+            frame_y = _safe_finite(y, 0.0)
+            frame_w = max(0.0, _safe_finite(width, 0.0))
+            frame_h = max(0.0, _safe_finite(height, 0.0))
             native_view.setTranslatesAutoresizingMaskIntoConstraints_(True)
             native_view.setFrame_(((frame_x, frame_y), (frame_w, frame_h)))
             _clamp_view_corner_radius(native_view, frame_w, frame_h)
@@ -2301,13 +2345,38 @@ class TabBarHandler(IOSViewHandler):
 
     def _set_bar_items(self, tab_bar: Any, items: list) -> None:
         UITabBarItem = ObjCClass("UITabBarItem")
+        UIImage = ObjCClass("UIImage")
         bar_items = []
         for i, item in enumerate(items):
             title = item.get("title", item.get("name", ""))
-            bar_item = UITabBarItem.alloc().initWithTitle_image_tag_(str(title), None, i)
+            image = self._resolve_icon(UIImage, item.get("icon"))
+            bar_item = UITabBarItem.alloc().initWithTitle_image_tag_(str(title), image, i)
             bar_items.append(bar_item)
         tab_bar.setItems_animated_(bar_items, False)
 
+    def _resolve_icon(self, UIImage: Any, icon: Any) -> Any:
+        """Resolve a tab icon spec to a UIImage, or return None.
+
+        Accepts a bare string (treated as an SF Symbol name) or a dict
+        of the form ``{"ios": "house.fill", "android": "..."}``. SF
+        Symbols are looked up via ``UIImage.systemImageNamed:``; names
+        that don't resolve produce a text-only tab.
+        """
+        if icon is None:
+            return None
+        name: Any = None
+        if isinstance(icon, str):
+            name = icon
+        elif isinstance(icon, dict):
+            name = icon.get("ios")
+        if not name:
+            return None
+        try:
+            image = UIImage.systemImageNamed_(str(name))
+            return image if image else None
+        except Exception:
+            return None
+
     def _set_active(self, tab_bar: Any, active: Any, items: list) -> None:
         if not active or not items:
             return

pythonnative/navigation.py

@@ -570,10 +570,14 @@ def _tab_navigator_impl(screens: Any = None, initial_route: Optional[str] = None
     if screen_def is None:
         screen_def = screen_map[screen_list[0].name]
 
-    tab_items: List[Dict[str, str]] = []
+    tab_items: List[Dict[str, Any]] = []
     for s in screen_list:
         if isinstance(s, _ScreenDef):
-            tab_items.append({"name": s.name, "title": s.options.get("title", s.name)})
+            item: Dict[str, Any] = {"name": s.name, "title": s.options.get("title", s.name)}
+            icon = s.options.get("tab_bar_icon")
+            if icon is not None:
+                item["icon"] = icon
+            tab_items.append(item)
 
     def on_tab_select(name: str) -> None:
         switch_tab(name)
@@ -639,8 +643,17 @@ def create_tab_navigator() -> Any:
                 name: Route name and default tab title.
                 component: A `@component` function rendered when this
                     tab is active.
-                options: Optional per-screen settings (e.g.,
-                    `{"title": "..."}`).
+                options: Optional per-screen settings. Recognized keys:
+
+                    - `title` (str): Tab label.
+                    - `tab_bar_icon` (str | dict): Native system icon
+                      identifier. A string is used on every platform; a
+                      dict like `{"ios": "house.fill", "android":
+                      "ic_menu_home"}` selects per platform. iOS values
+                      are resolved via SF Symbols
+                      (`UIImage.systemImageNamed_`); Android values are
+                      resolved against `android.R.drawable.<name>`.
+                      Names that don't resolve fall back to text-only.
 
             Returns:
                 A `_ScreenDef` consumed by `Navigator(...)`.

pythonnative/screen.py

@@ -341,6 +341,25 @@ def _hot_reload_tick(host: Any) -> bool:
     if not manifest_exists and last is None:
         return False
 
+    # The iOS template polls every 0.5s per UIViewController, so this
+    # tick fires several times per second per host. The per-tick log is
+    # gated behind ``PYTHONNATIVE_DEBUG`` to keep normal output quiet
+    # while preserving the breadcrumb when investigating reload races.
+    if _debug_enabled():
+        manifest_version: Optional[str] = None
+        if manifest_exists:
+            try:
+                with open(manifest_path, encoding="utf-8") as f:
+                    raw_version = json.load(f).get("version", "")
+                manifest_version = str(raw_version) if raw_version else None
+            except Exception:
+                manifest_version = None
+        action = "reload" if (manifest_version is not None and manifest_version != last) else "skip"
+        _log_pn(
+            f"_hot_reload_tick: host=0x{id(host):x} component={host._component_path} "
+            f"last={last!r} manifest={manifest_version!r} action={action}"
+        )
+
     next_version = ModuleReloader.reload_from_manifest(
         host,
         manifest_path,
@@ -348,10 +367,6 @@ def _hot_reload_tick(host: Any) -> bool:
     )
     if next_version == last:
         return False
-    _log_pn(
-        f"_hot_reload_tick: triggered reload "
-        f"(manifest_exists={manifest_exists}, last={last!r}, next={next_version!r})"
-    )
     host._hot_reload_last_version = next_version
     return True
 
@@ -365,6 +380,19 @@ def _reload_host(host: Any, changed_modules: Optional[Sequence[str]] = None) ->
     next render then runs the new bodies through the existing hook
     slots, so component state survives.
 
+    The reload set is **expanded** to include every currently-imported
+    module under the entry-point's top-level package (see
+    [`expand_reload_targets`][pythonnative.hot_reload.ModuleReloader.expand_reload_targets]).
+    This catches transitive ``from ... import`` bindings that would
+    otherwise remain stale: if ``app/main.py`` does
+    ``from app.screens.home import HomeScreen`` and the user edits
+    ``home.py``, reloading just ``app.screens.home`` leaves
+    ``app.main.HomeScreen`` pointing at the pre-edit function, so the
+    new render emits stale element types and the reconciler is forced
+    to unmount and remount the screen (losing state and showing old
+    code). Reloading every user-app module in dependency-friendly
+    order, with the entry-point last, keeps every binding fresh.
+
     If Fast Refresh fails (the new module raised at import time, no
     replacements could be located, or the next render itself
     threw), the host falls back to a full remount: a brand-new
@@ -374,14 +402,20 @@ def _reload_host(host: Any, changed_modules: Optional[Sequence[str]] = None) ->
     """
     from .hot_reload import ModuleReloader
 
-    modules = list(changed_modules or [])
-    root_module = host._component_path.rsplit(".", 1)[0] if "." in host._component_path else host._component_path
-    if root_module not in modules:
-        modules.append(root_module)
+    requested = list(changed_modules or [])
+    targets = ModuleReloader.expand_reload_targets(requested, host._component_path)
+
+    pending_version = getattr(host, "_hot_reload_pending_version", None)
+    already_loaded = pending_version is not None and pending_version == ModuleReloader._last_reloaded_version
+    _log_pn(
+        f"_reload_host: host=0x{id(host):x} component={host._component_path} "
+        f"requested={requested!r} targets={len(targets)} version={pending_version!r} "
+        f"action={'reuse_modules' if already_loaded else 'reload_modules'}"
+    )
 
-    reloaded = ModuleReloader.reload_modules(modules)
+    reloaded = ModuleReloader.reload_modules_for_version(targets, pending_version)
     if not reloaded:
-        _log_pn(f"_reload_host: no modules could be reloaded from {modules!r}; aborting")
+        _log_pn(f"_reload_host: no modules could be reloaded from {targets!r}; aborting")
         return
 
     try:
@@ -392,10 +426,11 @@ def _reload_host(host: Any, changed_modules: Optional[Sequence[str]] = None) ->
     host._component = new_component
 
     if host._reconciler is None:
+        _log_pn(f"_reload_host: host=0x{id(host):x} reconciler=None; skipping refresh")
         return
 
     if _try_fast_refresh(host, reloaded):
-        print(f"[hot-reload] Fast Refresh: {', '.join(reloaded)}", file=sys.stderr)
+        print(f"[hot-reload] Fast Refresh: {', '.join(requested) or ', '.join(reloaded)}", file=sys.stderr)
         return
 
     _full_remount(host, reloaded)
@@ -1080,7 +1115,7 @@ else:
                 nav = getattr(self.native_instance, "navigationController", None)
                 if nav is None:
                     raise RuntimeError(
-                        "No UINavigationController available; " "ensure template embeds root in navigation controller"
+                        "No UINavigationController available; ensure template embeds root in navigation controller"
                     )
                 nav.pushViewController_animated_(next_vc, True)
 

{pythonnative-0.13.0.dist-info → pythonnative-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.13.0
+Version: 0.14.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License

{pythonnative-0.13.0.dist-info → pythonnative-0.14.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
-pythonnative/__init__.py,sha256=rF3c2KY0L7hIbxvn6KheasH6I5Iex5ldAmDyhbyypgU,4121
+pythonnative/__init__.py,sha256=UWwcP6GyJyrIY7M3dd9zlYGLuFRql5MAEz1UB7lljvU,4121
 pythonnative/_ios_log.py,sha256=Oi7V28VxcVoZyrpAirvLeEmUW18McqnU87V4d37Zzlw,2582
 pythonnative/alerts.py,sha256=uU_b1rHGyxm1_hUzXhmTiB85oe7PZ0pWcWSzL9NVKYY,3588
 pythonnative/animated.py,sha256=0H3y7ZAtS4Lu9hqvCz1LTCORep57kb6S9ebyRoxO6-A,22051
 pythonnative/components.py,sha256=Pzyuu3qlqYb139-yeOLa290DkckgQZUVwsoGi1L8Gxk,44228
 pythonnative/element.py,sha256=W9varJj0Cl9HpckL8BcsC1u4ryUQOPVMrvetro4ilAE,2725
 pythonnative/hooks.py,sha256=j2FX7-66a-TK9ZlUsgoRyY8A484UgBzUJavGxaupgaI,27451
-pythonnative/hot_reload.py,sha256=In8RxY7WVIdgpNBfPWLOU3NPcmlp5aZ3m82w-IQ2FEg,18124
+pythonnative/hot_reload.py,sha256=j7z2c7o2Hdoyd-p4nQY15LTW7CBH_1z0TSAzLCer-aA,25036
 pythonnative/layout.py,sha256=-Wrvj4eHtQXqa9kn26ktKLAZVH4VMc_WuoCxV67UnQw,34994
-pythonnative/navigation.py,sha256=Ck728YpOWagjUyYcCDMpN9-kYXiseWhV7an3EvGvUCI,32564
+pythonnative/navigation.py,sha256=BtmdAKHocAF3ub7PewkGJYn8Rxy3GdV3serYnU0TMWk,33282
 pythonnative/platform.py,sha256=jEya1KTDc3WfwpmrQkk3DIFyt7CWO4Vc3pej_wDiSR8,4629
 pythonnative/platform_metrics.py,sha256=m2u8M8x52n5THNsYdspcaI9mlWWMbfSJWai1svjD0NM,8976
 pythonnative/reconciler.py,sha256=4z-55fYkQJlCqtxfDGlrI8MY2KxXgZxsJSB20d42acw,37898
-pythonnative/screen.py,sha256=5N3a01Tb-Yd-qsH1M9u3H_An67oPjeQpKXw86Ts9rY8,53011
+pythonnative/screen.py,sha256=-8m_L5QQxpMrX80j4XR2IjW2UtSKf9UCeggOHOK-RjY,55123
 pythonnative/style.py,sha256=8Bl1Ge8OrR-D9x2nAAGaW5VhbPCNQDWKbDEGJMWbGeQ,5758
 pythonnative/utils.py,sha256=pQSxa3QW06_Y9JzBSnK0g0eMV1VhXww8Qym6HPOGzgM,6064
 pythonnative/cli/__init__.py,sha256=NM1psvKe8jT0vzp8Ak4MMoygZz4P_msk5g-YEsY8xLk,232
@@ -21,10 +21,10 @@ pythonnative/native_modules/camera.py,sha256=EYSFcZSJbxRZz044ODzKHZ73CY6I3O7mQhU
 pythonnative/native_modules/file_system.py,sha256=NOaz1pM0XL3Ptu0Agg4v2XcsO8SLuOrgJGWpYKQu5_E,7505
 pythonnative/native_modules/location.py,sha256=Z4LBPphh20gwY88gxXkBfiJXXqFrFfiXQjDpjUNSTgE,8397
 pythonnative/native_modules/notifications.py,sha256=OIKleiiXXKscWTuobG9DTx18rxpIMLIFcTceSYgAgFY,6639
-pythonnative/native_views/__init__.py,sha256=tXYXb4k4dBRos8O6x0LnHRaZxy2sUINa_wAFIPXcW_I,7017
-pythonnative/native_views/android.py,sha256=hj_hI3V8y4yVL8QDoqdRYdO75aL_ugcUD3v9F4YAGD8,63116
+pythonnative/native_views/__init__.py,sha256=N4XS-spTLWuWeyPcGwY7ZHIP2jhqXYTHZIfsni8I_Eg,9989
+pythonnative/native_views/android.py,sha256=jedaq4PzmUw2Fyqy8H9l-xmiT7thxTGm2da8J2NEy-0,64235
 pythonnative/native_views/base.py,sha256=84YLJDouGcEvAZlfwBicv-DesRDnfkw1Go1t7udw6jM,8965
-pythonnative/native_views/ios.py,sha256=eP1PNBrraU1c_F7r-MmDImV6WKENqQ-cuxxVIbdNvjs,93832
+pythonnative/native_views/ios.py,sha256=nyQ61pZ6ATfePxvTOrNAqTBA1ZHObKg_IHcWK3zWWzY,96412
 pythonnative/templates/android_template/build.gradle,sha256=4gE6CRS6RuBu9kp-_e_uYYU9mBgHVZrqQg9caSxgyuc,352
 pythonnative/templates/android_template/gradle.properties,sha256=REPaKLRfQiiVfIV8wYmgwzPWvF1f3bhh_kAMV9p4HME,1358
 pythonnative/templates/android_template/gradlew,sha256=YxNShxF6Hm0SyEWA8fScYdG6AiGOzShmBgXpf5dufWU,5766
@@ -77,9 +77,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=l2Pwa50F_rv-qPu2go6e4bQernM6PTQJeNPFl_c4ivY,1387
 pythonnative/templates/ios_template/ios_templateUITests/ios_templateUITestsLaunchTests.swift,sha256=f5JrG0uVtLMeJQy26Yyz7Om-JUkT220osqcbeIVkj2g,815
-pythonnative-0.13.0.dist-info/licenses/LICENSE,sha256=A69iG7TIAe6KkGQf6xoVHkc5JSZtOr5eRSvC5iuivnI,1067
-pythonnative-0.13.0.dist-info/METADATA,sha256=MTpjFKT14sxGLBw0EI2EngLi4YrCiUGl0VIRdZrb1j8,7453
-pythonnative-0.13.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-pythonnative-0.13.0.dist-info/entry_points.txt,sha256=iUtDawWSAJAEyWTycpZxDuYz73ol31butpzDIEAgPO0,48
-pythonnative-0.13.0.dist-info/top_level.txt,sha256=kT4SEATY2ywzrZ2Pgea6_zxyym44Q_PbOsUoOYjJLFE,13
-pythonnative-0.13.0.dist-info/RECORD,,
+pythonnative-0.14.0.dist-info/licenses/LICENSE,sha256=A69iG7TIAe6KkGQf6xoVHkc5JSZtOr5eRSvC5iuivnI,1067
+pythonnative-0.14.0.dist-info/METADATA,sha256=OF1hl45kye50u38UrjPwmqDwWF2SatVWqucH4XlasWg,7453
+pythonnative-0.14.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pythonnative-0.14.0.dist-info/entry_points.txt,sha256=iUtDawWSAJAEyWTycpZxDuYz73ol31butpzDIEAgPO0,48
+pythonnative-0.14.0.dist-info/top_level.txt,sha256=kT4SEATY2ywzrZ2Pgea6_zxyym44Q_PbOsUoOYjJLFE,13
+pythonnative-0.14.0.dist-info/RECORD,,