pythonnative 0.32.0__py3-none-any.whl → 0.34.0__py3-none-any.whl

pythonnative/navigation/screen.py

@@ -0,0 +1,149 @@
+"""Screen definitions and the typed options a screen accepts."""
+
+from __future__ import annotations
+
+import sys
+from typing import Any, Callable, Dict, Literal, Mapping, Optional, TypedDict, Union
+
+if sys.version_info >= (3, 11):
+    from typing import Unpack
+else:  # pragma: no cover
+    from typing_extensions import Unpack
+
+from ..element import Element
+
+__all__ = ["HeaderSlot", "ScreenDef", "ScreenOptions", "Unpack"]
+
+HeaderSlot = Union[Element, Callable[[], Optional[Element]], None]
+"""An element (or zero-arg factory) rendered into a header slot."""
+
+
+class ScreenOptions(TypedDict, total=False):
+    """Per-screen options accepted by ``Screen(...)`` and ``nav.set_options(...)``.
+
+    All keys are optional. Navigators ignore keys they don't use; the
+    native host applies the header keys it can (see the platform notes
+    on each key).
+
+    Attributes:
+        title: Screen title. Stack navigators show it in the native
+            navigation bar; tab and drawer navigators use it as the item
+            label.
+        header_shown: Whether the native navigation bar is visible for
+            this screen (default ``True``).
+        header_large_title: iOS: use a large title that collapses on
+            scroll. Ignored elsewhere.
+        header_back_title: iOS: label of the back button shown on the
+            *next* screen when it navigates back to this one. Ignored
+            elsewhere.
+        header_back_visible: Whether the back button is shown
+            (default ``True``).
+        header_left: Element (or factory) rendered at the leading edge
+            of the navigation bar. Rendered by PythonNative into the bar
+            on iOS; ignored on Android and desktop today.
+        header_right: Element (or factory) rendered at the trailing edge
+            of the navigation bar (same platform notes as
+            ``header_left``).
+        header_tint_color: Color of the bar's buttons and back chevron.
+        header_style: Style dict for the bar itself; ``background_color``
+            is honored on every platform that draws a bar.
+        header_title_style: Style dict for the title label
+            (``color``, ``font_size``, ``bold``).
+        presentation: ``"card"`` (default) pushes; ``"modal"`` presents
+            the screen as a sheet on iOS and as a full-screen push
+            elsewhere.
+        gesture_enabled: Whether the interactive back gesture (iOS
+            swipe) can pop this screen (default ``True``).
+        animation: Transition to use when the screen is pushed:
+            ``"default"``, ``"none"``, ``"fade"``, ``"slide_from_right"``,
+            ``"slide_from_bottom"``. Only ``"none"`` versus animated is
+            distinguished on iOS and Android today.
+        tab_bar_icon: Native system icon identifier for tab items. A
+            string is used on every platform; a dict like
+            ``{"ios": "house.fill", "android": "ic_menu_home"}`` selects
+            per platform (SF Symbols on iOS, ``android.R.drawable.<name>``
+            on Android).
+        tab_bar_badge: Badge text or count shown on the tab item.
+        tab_bar_label: Label used for the tab item when it should differ
+            from ``title``.
+        lazy: Tab and drawer navigators only: mount the screen the first
+            time it's focused (default ``True``) instead of at
+            navigator mount.
+        unmount_on_blur: Tab and drawer navigators only: unmount the
+            screen when it loses focus instead of keeping it alive
+            hidden (default ``False``).
+    """
+
+    title: str
+    header_shown: bool
+    header_large_title: bool
+    header_back_title: str
+    header_back_visible: bool
+    header_left: HeaderSlot
+    header_right: HeaderSlot
+    header_tint_color: str
+    header_style: Dict[str, Any]
+    header_title_style: Dict[str, Any]
+    presentation: Literal["card", "modal"]
+    gesture_enabled: bool
+    animation: Literal["default", "none", "fade", "slide_from_right", "slide_from_bottom"]
+    tab_bar_icon: Union[str, Dict[str, str]]
+    tab_bar_badge: Union[str, int]
+    tab_bar_label: str
+    lazy: bool
+    unmount_on_blur: bool
+
+
+class ScreenDef:
+    """Configuration for one screen inside a navigator.
+
+    Created by ``Navigator.Screen(name, component, **options)``.
+
+    Attributes:
+        name: Route name used by ``nav.navigate(name)``.
+        component: The ``@component`` rendered when this screen is
+            active. Receives no props; read params with
+            [`use_route`][pythonnative.use_route].
+        options: Static [`ScreenOptions`][pythonnative.ScreenOptions]
+            for the screen. May be a callable ``(route) -> options`` to
+            derive options from the route's params.
+        initial_params: Params merged under any params supplied by
+            ``navigate`` when this screen is first shown.
+    """
+
+    __slots__ = ("name", "component", "options", "initial_params")
+
+    def __init__(
+        self,
+        name: str,
+        component: Callable[[], Any],
+        *,
+        options: Union[ScreenOptions, Callable[[Any], ScreenOptions], None] = None,
+        initial_params: Optional[Mapping[str, Any]] = None,
+        **option_kwargs: Unpack[ScreenOptions],
+    ) -> None:
+        if not name or not isinstance(name, str):
+            raise TypeError("Screen name must be a non-empty string")
+        if not callable(component):
+            raise TypeError(f"Screen {name!r}: component must be a @component, got {component!r}")
+        self.name = name
+        self.component = component
+        if callable(options):
+            if option_kwargs:
+                raise TypeError("Pass either a callable `options` or keyword options, not both")
+            self.options: Union[ScreenOptions, Callable[[Any], ScreenOptions]] = options
+        else:
+            merged: Dict[str, Any] = dict(options or {})
+            merged.update(option_kwargs)
+            self.options = merged  # type: ignore[assignment]
+        self.initial_params: Dict[str, Any] = dict(initial_params or {})
+
+    def resolve_options(self, route: Any) -> Dict[str, Any]:
+        """Return the static options, evaluating a callable ``options`` for ``route``."""
+        opts = self.options
+        if callable(opts):
+            return dict(opts(route) or {})
+        return dict(opts)
+
+    def __repr__(self) -> str:
+        return f"Screen({self.name!r})"

pythonnative/navigation/state.py

@@ -0,0 +1,248 @@
+"""Immutable navigation state and the pure operations on it.
+
+A navigator's state is a [`NavigationState`][pythonnative.navigation.NavigationState]:
+an ordered tuple of [`Route`][pythonnative.navigation.Route] entries
+plus the index of the active one. Stack navigators treat the tuple as
+a history (the active route is always the last); tab and drawer
+navigators keep one route per screen and move the index.
+
+Every operation returns a new state, so navigators can store the state
+in ``use_state`` and diff it like any other value. States serialize to
+plain dicts (``to_dict`` / ``from_dict``) so a native host can hand a
+pushed screen the full history it belongs to.
+"""
+
+from __future__ import annotations
+
+import itertools
+from typing import Any, Dict, Iterable, Iterator, Mapping, Optional, Sequence, Tuple
+
+__all__ = ["NavigationState", "Route"]
+
+_route_keys = itertools.count(1)
+
+
+def _new_key(name: str) -> str:
+    return f"{name}-{next(_route_keys)}"
+
+
+class Route:
+    """One entry in a navigator's state.
+
+    Attributes:
+        name: The screen name this route renders.
+        params: Parameters passed to the screen (read with
+            [`use_route`][pythonnative.use_route]).
+        key: Stable identity for this particular visit to the screen,
+            unique per process. Two pushes of the same screen have
+            different keys, so their component state never mixes.
+        state: Seed state for a navigator rendered by this screen
+            (set by ``navigate("Tabs", screen="Profile")`` and by deep
+            links). ``None`` for ordinary screens.
+    """
+
+    __slots__ = ("name", "params", "key", "state")
+
+    def __init__(
+        self,
+        name: str,
+        params: Optional[Mapping[str, Any]] = None,
+        key: Optional[str] = None,
+        state: Optional["NavigationState"] = None,
+    ) -> None:
+        self.name = name
+        self.params: Dict[str, Any] = dict(params or {})
+        self.key = key or _new_key(name)
+        self.state = state
+
+    def with_params(self, params: Mapping[str, Any], *, merge: bool = True) -> "Route":
+        """Return a copy carrying ``params`` (merged over the current ones by default)."""
+        merged = {**self.params, **params} if merge else dict(params)
+        return Route(self.name, merged, key=self.key, state=self.state)
+
+    def with_state(self, state: Optional["NavigationState"]) -> "Route":
+        """Return a copy carrying a nested navigator seed ``state``."""
+        return Route(self.name, self.params, key=self.key, state=state)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize to a plain dict (``name``, ``params``, ``key``, and ``state`` when nested)."""
+        out: Dict[str, Any] = {"name": self.name, "params": dict(self.params), "key": self.key}
+        if self.state is not None:
+            out["state"] = self.state.to_dict()
+        return out
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> "Route":
+        """Rebuild a route from ``to_dict`` output, keeping its ``key`` so component state carries over."""
+        params = data.get("params")
+        nested = data.get("state")
+        return cls(
+            str(data["name"]),
+            params if isinstance(params, Mapping) else {},
+            key=data.get("key"),
+            state=NavigationState.from_dict(nested) if isinstance(nested, Mapping) and nested.get("routes") else None,
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Route):
+            return NotImplemented
+        return (
+            self.name == other.name
+            and self.params == other.params
+            and self.key == other.key
+            and self.state == other.state
+        )
+
+    def __hash__(self) -> int:
+        return hash(self.key)
+
+    def __repr__(self) -> str:
+        return f"Route({self.name!r}, params={self.params!r}, key={self.key!r})"
+
+
+class NavigationState:
+    """Immutable ordered routes plus the active index.
+
+    Attributes:
+        routes: The routes, oldest first.
+        index: Position of the active route in ``routes``.
+    """
+
+    __slots__ = ("routes", "index")
+
+    def __init__(self, routes: Iterable[Route], index: Optional[int] = None) -> None:
+        self.routes: Tuple[Route, ...] = tuple(routes)
+        if not self.routes:
+            raise ValueError("NavigationState needs at least one route")
+        self.index = len(self.routes) - 1 if index is None else index
+        if not 0 <= self.index < len(self.routes):
+            raise IndexError(f"index {self.index} out of range for {len(self.routes)} route(s)")
+
+    # ------------------------------------------------------------------
+    # Introspection
+    # ------------------------------------------------------------------
+
+    @property
+    def current(self) -> Route:
+        """The active route."""
+        return self.routes[self.index]
+
+    @property
+    def can_go_back(self) -> bool:
+        """Whether a route precedes the active one."""
+        return self.index > 0
+
+    def find(self, name: str) -> Optional[int]:
+        """Index of the most recent route named ``name``, or ``None``."""
+        for i in range(len(self.routes) - 1, -1, -1):
+            if self.routes[i].name == name:
+                return i
+        return None
+
+    def __len__(self) -> int:
+        return len(self.routes)
+
+    def __iter__(self) -> Iterator[Route]:
+        return iter(self.routes)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, NavigationState):
+            return NotImplemented
+        return self.routes == other.routes and self.index == other.index
+
+    def __repr__(self) -> str:
+        names = [r.name for r in self.routes]
+        return f"NavigationState({names!r}, index={self.index})"
+
+    # ------------------------------------------------------------------
+    # Stack operations (history semantics)
+    # ------------------------------------------------------------------
+
+    def push(
+        self, name: str, params: Optional[Mapping[str, Any]] = None, state: Optional["NavigationState"] = None
+    ) -> "NavigationState":
+        """Append a new route and make it active (drops any forward entries)."""
+        kept = self.routes[: self.index + 1]
+        return NavigationState(kept + (Route(name, params, state=state),))
+
+    def pop(self, count: int = 1) -> "NavigationState":
+        """Remove up to ``count`` routes from the end (never below one)."""
+        keep = max(1, len(self.routes) - max(0, count))
+        return NavigationState(self.routes[:keep])
+
+    def pop_to_top(self) -> "NavigationState":
+        """Keep only the first route."""
+        return NavigationState(self.routes[:1])
+
+    def pop_to(
+        self, name: str, params: Optional[Mapping[str, Any]] = None, state: Optional["NavigationState"] = None
+    ) -> "NavigationState":
+        """Pop back to the most recent route named ``name``, merging ``params`` into it."""
+        idx = self.find(name)
+        if idx is None:
+            raise KeyError(name)
+        routes = list(self.routes[: idx + 1])
+        if params:
+            routes[-1] = routes[-1].with_params(params)
+        if state is not None:
+            routes[-1] = routes[-1].with_state(state)
+        return NavigationState(routes)
+
+    def replace(
+        self, name: str, params: Optional[Mapping[str, Any]] = None, state: Optional["NavigationState"] = None
+    ) -> "NavigationState":
+        """Swap the active route for a fresh one (new key, so state resets)."""
+        routes = list(self.routes)
+        routes[self.index] = Route(name, params, state=state)
+        return NavigationState(routes, self.index)
+
+    def navigate(
+        self, name: str, params: Optional[Mapping[str, Any]] = None, state: Optional["NavigationState"] = None
+    ) -> "NavigationState":
+        """Go to ``name``: pop back to it if it's in the history, else push it."""
+        if self.find(name) is not None:
+            return self.pop_to(name, params, state)
+        return self.push(name, params, state)
+
+    # ------------------------------------------------------------------
+    # Tab / drawer operations (one route per screen)
+    # ------------------------------------------------------------------
+
+    def jump_to(
+        self, name: str, params: Optional[Mapping[str, Any]] = None, state: Optional["NavigationState"] = None
+    ) -> "NavigationState":
+        """Activate the route named ``name`` in place, merging ``params``."""
+        idx = self.find(name)
+        if idx is None:
+            raise KeyError(name)
+        routes = list(self.routes)
+        if params:
+            routes[idx] = routes[idx].with_params(params)
+        if state is not None:
+            routes[idx] = routes[idx].with_state(state)
+        return NavigationState(routes, idx)
+
+    # ------------------------------------------------------------------
+    # Shared
+    # ------------------------------------------------------------------
+
+    def set_params(self, params: Mapping[str, Any]) -> "NavigationState":
+        """Merge ``params`` into the active route."""
+        routes = list(self.routes)
+        routes[self.index] = routes[self.index].with_params(params)
+        return NavigationState(routes, self.index)
+
+    def reset(self, routes: Sequence[Route], index: Optional[int] = None) -> "NavigationState":
+        """Return a state holding exactly ``routes`` with ``index`` active (the last route by default)."""
+        return NavigationState(routes, index)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize to a plain dict with ``routes`` (each via ``Route.to_dict``) and ``index``."""
+        return {"routes": [r.to_dict() for r in self.routes], "index": self.index}
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> "NavigationState":
+        """Rebuild a state from ``to_dict`` output; a missing ``index`` activates the last route."""
+        routes = [Route.from_dict(r) for r in data.get("routes", [])]
+        index = data.get("index")
+        return cls(routes, int(index) if isinstance(index, int) else None)

pythonnative/net.py

@@ -77,6 +77,10 @@ class Response:
         """``True`` if the status is in the 2xx range."""
         return 200 <= self.status < 300
 
+    def __repr__(self) -> str:
+        cls = type(self).__name__
+        return f"{cls}(status={self.status}, url={self.url!r}, ok={self.ok}, content={len(self.content)} bytes)"
+
     def text(self, encoding: Optional[str] = None) -> str:
         """Decode ``content`` to ``str``.
 

pythonnative/platform_metrics.py

@@ -1,6 +1,6 @@
 """Platform-level metrics shared between screen hosts and view handlers.
 
-The screen host (`pythonnative.screen`) is the only place that knows
+The screen host (`pythonnative.hosts`) is the only place that knows
 about native window/safe-area state because it is the only piece of
 code that holds a reference to the native ``UIViewController``
 (iOS) or ``Activity`` (Android). Native view handlers, however, need

pythonnative/preview.py

@@ -12,9 +12,9 @@ Architecture
   navigation stack gets its own child container inside the stage; the
   desktop view handlers create widgets under the active container.
 - [`DesktopApp`][pythonnative.preview.DesktopApp] owns the navigation
-  stack of [`screen`][pythonnative.screen] hosts and the push/pop/reset
-  primitives the declarative navigators call through ``host._push`` /
-  ``host._pop``.
+  stack of [`hosts`][pythonnative.hosts] and the push/pop/reset
+  primitives a root ``Stack.Navigator`` reaches through the host's
+  [`HostNavigator`][pythonnative.navigation.HostNavigator] methods.
 - The Tk event loop runs on the main thread. A lightweight poll
   (`~60 Hz`) drains (a) UI work marshaled from the asyncio runtime
   thread via [`runtime.call_on_main_thread`][pythonnative.runtime.call_on_main_thread],
@@ -77,7 +77,7 @@ class DesktopApp:
     """Navigation-stack controller for the desktop preview window.
 
     One instance backs a preview session. It is handed to each
-    [`screen`][pythonnative.screen] host as the ``native_instance`` so
+    [`DesktopScreenHost`][pythonnative.hosts.desktop.DesktopScreenHost] as the ``native_instance`` so
     hosts can drive navigation (``push_screen`` / ``pop_screen`` /
     ``reset_to_root``), report the viewport size, and set the window
     title, mirroring the role a ``UIViewController`` / ``Activity``
@@ -116,7 +116,7 @@ class DesktopApp:
         return frame
 
     def _show_container(self, host: Any) -> None:
-        container = getattr(host, "_pn_container", None)
+        container = getattr(host, "container", None)
         if container is not None:
             try:
                 container.place(in_=self._stage, x=0, y=0, relwidth=1.0, relheight=1.0)
@@ -125,7 +125,7 @@ class DesktopApp:
                 pass
 
     def _forget_container(self, host: Any) -> None:
-        container = getattr(host, "_pn_container", None)
+        container = getattr(host, "container", None)
         if container is not None:
             try:
                 container.place_forget()
@@ -136,19 +136,19 @@ class DesktopApp:
         """Make ``host`` the rendering target and reflow it to the viewport."""
         from .native_views import desktop as desktop_backend
 
-        desktop_backend.set_root_container(getattr(host, "_pn_container", None))
+        desktop_backend.set_root_container(getattr(host, "container", None))
         self._show_container(host)
 
     # -- lifecycle ----------------------------------------------------
 
     def _make_host(self, component_path: str, args: Optional[dict] = None) -> Any:
-        from . import screen as screen_module
+        from .hosts import create_screen
         from .native_views import desktop as desktop_backend
 
         container = self._new_container()
         desktop_backend.set_root_container(container)
-        host = screen_module.create_screen(component_path, self)
-        host._pn_container = container
+        host = create_screen(component_path, self)
+        host.container = container
         if args:
             host.set_args(args)
         return host
@@ -178,8 +178,8 @@ class DesktopApp:
             self._mount_failed = True
             self._show_error(traceback.format_exc())
 
-    def push_screen(self, component_path: str, args: Optional[dict] = None) -> None:
-        """Push a new screen, suspending the current one (declarative nav)."""
+    def push_screen(self, component_path: str, args: Optional[dict] = None, options: Optional[dict] = None) -> None:
+        """Push a new screen, suspending the current one (root stack navigation)."""
         if self._stack:
             current = self._stack[-1]
             try:
@@ -196,6 +196,8 @@ class DesktopApp:
         try:
             host.on_create()
             host.on_resume()
+            if options and options.get("title"):
+                self.set_title(str(options["title"]))
         except Exception:
             self._show_error(traceback.format_exc())
 
@@ -233,12 +235,12 @@ class DesktopApp:
             pass
         # ``on_destroy`` unmounts the host's reconciler: effect cleanups
         # run, native widgets are destroyed, and event registrations are
-        # released (see ``screen._destroy_host``).
+        # released.
         try:
             host.on_destroy()
         except Exception:
             pass
-        container = getattr(host, "_pn_container", None)
+        container = getattr(host, "container", None)
         if container is not None:
             try:
                 container.destroy()
@@ -305,14 +307,14 @@ class DesktopApp:
 
         self._clear_error()
         for host in self._stack:
-            desktop_backend.set_root_container(getattr(host, "_pn_container", None))
+            desktop_backend.set_root_container(getattr(host, "container", None))
             try:
                 host.reload(changed_modules)
             except Exception:
                 self._show_error(traceback.format_exc())
         active = self.active_host()
         if active is not None:
-            desktop_backend.set_root_container(getattr(active, "_pn_container", None))
+            desktop_backend.set_root_container(getattr(active, "container", None))
 
     def _remount_root(self) -> None:
         for host in list(self._stack):
@@ -383,7 +385,7 @@ def run_preview(
     Args:
         component_path: Module path (``"app.main"`` → its ``App``) or a
             dotted ``module.Component`` path, same convention as
-            [`create_screen`][pythonnative.create_screen].
+            [`create_screen`][pythonnative.hosts.create_screen].
         project_root: Directory added to ``sys.path`` so the component
             imports. Defaults to the current working directory.
         watch_dir: Directory watched for ``.py`` changes. Defaults to
@@ -449,7 +451,7 @@ def run_preview(
         watcher.start()
         print(f"[pn preview] watching {watched} for changes", file=sys.stderr)
 
-    from . import screen as screen_module
+    from .hosts import drain_desktop_scheduled_renders
 
     def _poll() -> None:
         for _ in range(128):
@@ -462,7 +464,7 @@ def run_preview(
             except Exception:
                 traceback.print_exc()
         try:
-            screen_module.drain_desktop_scheduled_renders()
+            drain_desktop_scheduled_renders()
         except Exception:
             traceback.print_exc()
         try:

pythonnative/project/android.py

@@ -234,7 +234,7 @@ def configure_settings_gradle(project_dir: Path, config: AppConfig) -> None:
 
 
 def configure_strings(project_dir: Path, config: AppConfig) -> None:
-    """Set the ``app_name`` string resource to the display name.
+    """Set the ``app_name`` and ``pn_entry_module`` string resources.
 
     Args:
         project_dir: The staged Android project root.
@@ -251,6 +251,12 @@ def configure_strings(project_dir: Path, config: AppConfig) -> None:
         content,
         flags=re.DOTALL,
     )
+    content = re.sub(
+        r'(<string name="pn_entry_module"[^>]*>)(.*?)(</string>)',
+        rf"\g<1>{_xml_escape(config.entry_module)}\g<3>",
+        content,
+        flags=re.DOTALL,
+    )
     strings_path.write_text(content, encoding="utf-8")
 
 

pythonnative/project/doctor.py

@@ -181,7 +181,7 @@ def check_ios(config: Optional[AppConfig]) -> List[CheckResult]:
                 CheckResult(
                     "iOS embedded Python",
                     WARN,
-                    f"app.python_version={config.python_version}; pinned iOS builds " f"exist for {supported}",
+                    f"app.python_version={config.python_version}; pinned iOS builds exist for {supported}",
                 )
             )
         if config.ios.development_team:

pythonnative/project/ios.py

@@ -126,6 +126,7 @@ def configure_info_plist(info_plist: Path, config: AppConfig) -> None:
 
     plist["CFBundleDisplayName"] = config.display_name
     plist["CFBundleName"] = config.name
+    plist["PNEntryModule"] = config.entry_module
 
     orientations = _ORIENTATIONS.get(config.orientation, _ORIENTATIONS["portrait"])
     plist["UISupportedInterfaceOrientations"] = list(orientations)

pythonnative/project/runtime_assets.py

@@ -143,7 +143,7 @@ def prepare_ios_runtime(
     if pinned is None:
         supported = ", ".join(sorted(PINNED_ASSETS))
         raise RuntimeError(
-            f"No pinned iOS runtime for Python {python_version}. " f"Set app.python_version to one of: {supported}."
+            f"No pinned iOS runtime for Python {python_version}. Set app.python_version to one of: {supported}."
         )
     tag, asset_name, expected_sha = pinned
 

pythonnative/reconciler/__init__.py

@@ -0,0 +1,29 @@
+"""Reconciler package: turns element trees into batched native mutations.
+
+The public surface is [`Reconciler`][pythonnative.reconciler.core.Reconciler] and
+[`VNode`][pythonnative.reconciler.vnode.VNode]; the remaining modules are
+implementation detail:
+
+- ``core``: render, diff, commit.
+- ``boundaries``: ``ErrorBoundary``
+  and ``Suspense``.
+- ``layout_pass``: the flexbox
+  pass and frame diffing.
+- ``children``: minimal move
+  planning for keyed child lists.
+- ``vnode``: the mounted-tree node and
+  pure helpers.
+"""
+
+from .children import plan_child_moves
+from .core import Reconciler
+from .vnode import VNode, next_tag, normalize_children, shallow_equal_props
+
+__all__ = [
+    "Reconciler",
+    "VNode",
+    "next_tag",
+    "normalize_children",
+    "plan_child_moves",
+    "shallow_equal_props",
+]