pythonnative 0.22.0__py3-none-any.whl → 0.22.1__py3-none-any.whl

pythonnative/__init__.py

@@ -60,7 +60,7 @@ Example:
     ```
 """
 
-__version__ = "0.22.0"
+__version__ = "0.22.1"
 
 from . import gestures, runtime, sdk
 from .alerts import Alert

pythonnative/animated.py

@@ -24,7 +24,7 @@ native view the value is attached to
 
 - **Accepted** (iOS Core Animation, Android ``ViewPropertyAnimator`` /
   ``DynamicAnimation``): the platform animates the property entirely
-  natively — no Python code runs per frame. Python receives exactly one
+  natively; no Python code runs per frame. Python receives exactly one
   callback when the animation settles, updates the
   [`AnimatedValue`][pythonnative.animated.AnimatedValue], and resolves
   any awaiting tasks.
@@ -135,7 +135,7 @@ class AnimatedValue:
     Animated components (``Animated.View`` et al.) **attach** the value
     to ``(tag, prop)`` bindings after mount. Setting the value pushes
     the new number to every attached native view through the registry's
-    ``set_animated_property`` — and when an animation can be driven
+    ``set_animated_property``, and when an animation can be driven
     natively, the platform animates those same bindings directly.
 
     Python-side listeners registered via
@@ -217,7 +217,7 @@ class AnimatedValue:
     def add_listener(self, prop: str, callback: Callable[[float], None]) -> Callable[[], None]:
         """Register ``callback`` for Python-driven changes to this value.
 
-        Returns an unsubscribe callable. ``prop`` is metadata only — it
+        Returns an unsubscribe callable. ``prop`` is metadata only; it
         lets the subscriber differentiate this binding from others on
         the same ``AnimatedValue``.
         """
@@ -686,7 +686,7 @@ class _AnimationHandle(_AwaitableAnimation):
 
     Each ``.start()`` call snapshots the value's current state, prefers
     the native driver, and falls back to a fresh Python-ticked
-    animation otherwise (matches React Native — the ``Animated.timing``
+    animation otherwise (matches React Native: the ``Animated.timing``
     return value is reusable).
     """
 
@@ -780,7 +780,7 @@ class _CompositeAnimation(_AwaitableAnimation):
         if item is None:
             return
         # ``_AwaitableAnimation`` and plain awaitables/coroutines are
-        # both supported — lets users mix in ``asyncio.sleep``.
+        # both supported: lets users mix in ``asyncio.sleep``.
         await item
 
 
@@ -824,7 +824,7 @@ def _make_animated_factory(
 
         # ``@component`` packs positional children into the ``children``
         # prop (this function declares ``*args``), and the reconciler
-        # re-invokes it with keyword props only — so at render time the
+        # re-invokes it with keyword props only, so at render time the
         # payload arrives in ``kwargs``, never in ``args``.
         children = list(args) or list(kwargs.pop("children", ()) or ())
 

pythonnative/cli/pn.py

@@ -5,7 +5,7 @@ The console script `pn` (declared in `pyproject.toml`) dispatches to:
 - `pn init [name]`: scaffold a new project (``pythonnative.toml`` + ``app/``).
 - `pn doctor [platform]`: diagnose the local toolchain and config.
 - `pn preview [component]`: render the app in a desktop (Tkinter) window
-  with Fast Refresh — the fast inner dev loop, no device required.
+  with Fast Refresh, the fast inner dev loop, no device required.
 - `pn run android|ios`: stage + build + install + launch on a device or
   simulator, with optional on-device hot reload.
 - `pn build android|ios`: produce standalone artifacts (signed APK/AAB,

pythonnative/components.py

@@ -1,7 +1,7 @@
 """Built-in element factories and the typed prop schemas they share.
 
-Each ``@dataclass(frozen=True)`` class in this module — ``TextProps``,
-``ButtonProps``, etc. — is the canonical schema for one built-in
+Each ``@dataclass(frozen=True)`` class in this module (``TextProps``,
+``ButtonProps``, etc.) is the canonical schema for one built-in
 component. Each factory function (``Text``, ``Button``, …) is a thin
 ergonomic wrapper that builds an [`Element`][pythonnative.Element]
 through the shared :func:`_make_element` helper, so style resolution,
@@ -827,7 +827,7 @@ def Spacer(
 
     Args:
         size: Fixed gap in dp/pt along the parent's main axis. Mirrored
-            on both axes — whichever axis the parent's
+            on both axes: whichever axis the parent's
             ``flex_direction`` chooses as main becomes the actual gap.
         flex: Flex-grow weight; useful for pushing siblings to the
             opposite end of a [`Row`][pythonnative.Row] or
@@ -912,14 +912,14 @@ def View(
     - ``flex_direction``: ``"column"`` (default), ``"row"``,
       ``"column_reverse"``, ``"row_reverse"``.
     - ``flex_wrap``: ``"nowrap"`` (default), ``"wrap"``,
-      ``"wrap_reverse"`` — with ``align_content`` controlling how
+      ``"wrap_reverse"``, with ``align_content`` controlling how
       wrapped lines share leftover cross-axis space.
     - ``justify_content``: main-axis distribution. Accepts
       ``"flex_start"`` (default), ``"center"``, ``"flex_end"``,
       ``"space_between"``, ``"space_around"``, ``"space_evenly"``.
     - ``align_items``: cross-axis alignment. Accepts ``"stretch"``
       (default), ``"flex_start"``, ``"center"``, ``"flex_end"``.
-    - ``direction``: ``"ltr"`` (default) or ``"rtl"`` — flips rows and
+    - ``direction``: ``"ltr"`` (default) or ``"rtl"``. Flips rows and
       resolves ``margin_start`` / ``padding_end`` / absolute ``start``
       / ``end`` insets.
     - ``overflow``: ``"visible"`` (default) or ``"hidden"``.
@@ -1061,7 +1061,7 @@ def ScrollView(
             wrapper (padding, alignment, spacing of the scrollable
             content), distinct from ``style`` (the scroll view frame).
         keyboard_dismiss_mode: ``"none"`` (default), ``"on_drag"``, or
-            ``"interactive"`` — controls whether scrolling dismisses
+            ``"interactive"``. Controls whether scrolling dismisses
             the keyboard.
         style: Style dict (or list of dicts).
         ref: Optional ``use_ref()`` dict.
@@ -1145,7 +1145,7 @@ def Modal(
         animation_type: ``"slide"`` (default), ``"fade"``, or ``"none"``.
         transparent: When ``True``, the underlying view is dimmed
             instead of fully covered.
-        presentation_style: iOS presentation style —
+        presentation_style: iOS presentation style,
             ``"page_sheet"`` (default), ``"form_sheet"``,
             ``"full_screen"``, or ``"overlay"`` (custom dimmed
             overlay). On Android, ``"overlay"`` keeps the dialog
@@ -1604,8 +1604,8 @@ def ErrorBoundary(
 # ======================================================================
 #
 # FlatList and SectionList are pure Python components, not native
-# elements. They render a windowed slice of rows into a ScrollView —
-# leading spacer, visible rows, trailing spacer — and shift the window
+# elements. They render a windowed slice of rows into a ScrollView
+# (leading spacer, visible rows, trailing spacer) and shift the window
 # from scroll events (the same architecture as React Native's
 # VirtualizedList). Because every windowed row lives in the *main*
 # layout tree, rows may be any height: estimates only steer the spacer
@@ -1872,7 +1872,7 @@ def FlatList(
     leading and trailing spacers stand in for everything else, and the
     window shifts as the user scrolls. Rows may have **variable
     heights**: pass ``item_height`` when rows are uniform,
-    ``get_item_height`` for exact per-item extents, or nothing at all —
+    ``get_item_height`` for exact per-item extents, or nothing at all;
     unknown rows start at ``estimated_item_height`` and are corrected
     with their measured extent once they've been on screen.
 
@@ -2040,7 +2040,7 @@ def SectionList(
 
     Flattens ``sections`` into a single virtualized sequence where each
     entry is either a header or an item, then reuses the same windowing
-    engine as [`FlatList`][pythonnative.FlatList] — headers and items
+    engine as [`FlatList`][pythonnative.FlatList]; headers and items
     may have different (and variable) heights.
 
     Args:
@@ -2177,7 +2177,7 @@ def StatusBar(
             ``"dark"`` (dark icons over light backgrounds), or
             ``"default"`` (system default).
         background_color: Color of the status-bar background (Android
-            only — iOS draws the bar transparent over your content).
+            only; iOS draws the bar transparent over your content).
         hidden: When ``True``, the status bar is hidden.
         key: Stable identity for keyed reconciliation.
 

pythonnative/events.py

@@ -10,7 +10,7 @@ the bridge. This module replaces that with a single dispatch channel:
 - Handlers wire their platform listener **once** at view creation; the
   listener calls [`dispatch_event`][pythonnative.events.dispatch_event]
   with the view's tag and the event name.
-- Re-renders only mutate this Python-side registry — no native call is
+- Re-renders only mutate this Python-side registry; no native call is
   made when just a callback identity changes.
 
 The set of event names present on an element is forwarded to handlers
@@ -78,7 +78,7 @@ class EventRegistry:
 
         Returns:
             ``True`` when a callback existed and was invoked (even if
-            it raised — exceptions are swallowed so a buggy app
+            it raised: exceptions are swallowed so a buggy app
             callback can't crash the platform's UI thread), ``False``
             when nothing is registered.
         """
@@ -115,7 +115,7 @@ def dispatch_event(tag: int, name: str, *args: Any) -> bool:
 
     Args:
         tag: The view's reconciler-assigned tag.
-        name: Event name — the original prop name (``"on_click"``,
+        name: Event name, the original prop name (``"on_click"``,
             ``"on_change"``, …) or a gesture channel (``"gesture:0"``).
         *args: Positional arguments forwarded to the user callback,
             preserving each prop's documented signature.
@@ -144,8 +144,8 @@ def extract_events(props: Dict[str, Any]) -> Tuple[Dict[str, Any], Dict[str, Cal
     - ``gestures`` lists of gesture descriptors are serialized to plain
       dicts (handlers wire recognizers from them) while their callbacks
       are folded into per-gesture ``"gesture:<i>"`` routers.
-    - The resulting payload carries ``_pn_events`` — a frozenset of the
-      event names present — so handlers can wire listeners
+    - The resulting payload carries ``_pn_events`` (a frozenset of the
+      event names present), so handlers can wire listeners
       conditionally and the prop differ can detect listener
       addition/removal without comparing closures.
 

pythonnative/gestures.py

@@ -351,7 +351,7 @@ def serialize_gestures(
 # guarantees identical semantics on both backends.
 
 EmitFn = Callable[[int, Dict[str, Any]], None]
-"""``emit(gesture_index, payload)`` — the arbiter's output channel."""
+"""``emit(gesture_index, payload)``: the arbiter's output channel."""
 
 
 class _VelocityTracker:
@@ -400,7 +400,7 @@ class _Recognizer:
     def kind(self) -> str:
         return str(self.config.get("kind", ""))
 
-    # Event hooks — ``pointers`` maps pointer id -> (x, y).
+    # Event hooks: ``pointers`` maps pointer id -> (x, y).
     def down(self, pointers: Dict[int, Tuple[float, float]], t: float) -> None:
         pass
 
@@ -805,7 +805,7 @@ class GestureArbiter:
 
     One arbiter serves one view. The host backend feeds it normalized
     pointer events (positions in the view's coordinate space, times in
-    seconds — any monotonic clock) and provides an ``emit`` callback
+    seconds, any monotonic clock) and provides an ``emit`` callback
     that forwards ``(gesture_index, payload)`` pairs to
     [`dispatch_event`][pythonnative.events.dispatch_event].
 

pythonnative/hooks.py

@@ -613,7 +613,7 @@ def use_query(
     Args:
         fetcher: Zero-arg ``async`` callable that resolves to the
             current data.
-        deps: Dependency list — refetches whenever any entry changes.
+        deps: Dependency list. Refetches whenever any entry changes.
         initial: Optional starting value for ``data`` before the
             first fetch completes.
 
@@ -698,7 +698,7 @@ class MutationCall(Generic[T]):
     Returned by the second element of the
     [`use_mutation`][pythonnative.use_mutation] tuple. Awaiting the
     handle resolves to the mutator's return value (or re-raises its
-    exception); discarding the handle is safe — Python won't warn
+    exception); discarding the handle is safe. Python won't warn
     about an unawaited coroutine because this is a plain object.
 
     Example:
@@ -1068,7 +1068,7 @@ class NavigationHandle:
     Wraps the host's push/pop primitives so screens can navigate
     without knowing the underlying native navigation stack. The
     typical user-facing surface is the declarative handle returned by
-    a [`Stack`][pythonnative.create_stack_navigator] — this class is
+    a [`Stack`][pythonnative.create_stack_navigator]; this class is
     the lower-level fallback used when no navigator is rendered (and
     as the bridge that declarative navigators delegate to when they
     need to push real native screens).

pythonnative/hot_reload.py

@@ -17,7 +17,7 @@ Two strategies share the device-side surface:
   the reconciler tree is walked and every component function whose
   module was reloaded is swapped in place. Hook state, navigation
   state, and even scroll positions survive because the underlying
-  ``VNode`` objects are reused — the next render simply calls the
+  ``VNode`` objects are reused; the next render simply calls the
   new function bodies through the old slots.
 - **Full remount**: when the in-place swap fails (e.g. the new
   module raised at import time, or a render exception bubbled out
@@ -197,8 +197,8 @@ class ModuleReloader:
 
     Designed to be invoked from device-side glue when a hot-reload
     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
+    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
@@ -302,7 +302,7 @@ class ModuleReloader:
 
         Returns:
             The list of module names that are currently fresh in
-            ``sys.modules`` — either freshly reloaded by this call, or
+            ``sys.modules``, either freshly reloaded by this call, or
             already reloaded by an earlier host for the same version.
         """
         with ModuleReloader._reload_lock:

pythonnative/layout.py

@@ -9,7 +9,7 @@ The engine is invoked by the reconciler after each commit pass:
 
 1. The reconciler maintains a parallel
    [`LayoutNode`][pythonnative.layout.LayoutNode] tree (cached across
-   passes — clean subtrees keep their nodes, dirty ones are rebuilt).
+   passes: clean subtrees keep their nodes, dirty ones are rebuilt).
 2. [`calculate_layout`][pythonnative.layout.calculate_layout] is called
    with the viewport size; it recursively determines each node's
    ``(x, y, width, height)`` relative to its parent's coordinate space.
@@ -618,7 +618,7 @@ def _measure_node(
     resolved_direction = _resolve_direction(style, direction)
 
     # Incremental-layout memo: a clean node measured under identical
-    # inputs reuses its previous result without recursing — its whole
+    # inputs reuses its previous result without recursing; its whole
     # subtree keeps the sizes from the prior pass.
     memo = node._measure_memo
     if (
@@ -863,7 +863,7 @@ def _layout_flex_children(
     their line's cross size. The computed line structure is stored on
     ``parent._lines`` for the positioning pass.
 
-    Returns ``(used_main, used_cross)`` — the total content size used
+    Returns ``(used_main, used_cross)``, the total content size used
     by the in-flow children, including inter-child gaps but excluding
     the parent's own padding. The caller adds padding back in for the
     container's outer size.

pythonnative/mutations.py

@@ -49,7 +49,7 @@ class CreateOp:
     Attributes:
         tag: Unique integer identity assigned by the reconciler.
         type_name: Element type name (e.g. ``"Text"``).
-        props: Initial *clean* props — callables have already been
+        props: Initial *clean* props; callables have already been
             routed to the [`EventRegistry`][pythonnative.events.EventRegistry]
             and replaced by the ``_pn_events`` name set.
     """

pythonnative/native_modules/camera.py

@@ -152,7 +152,7 @@ def _ios_launch_picker(on_result: Callable[[Optional[str]], None], source: str)
             _pending_delegates.pop(id(delegate), None)
             on_result(None)
 
-        # Reference SEL/objc_method so the lint pass keeps the import —
+        # Reference SEL/objc_method so the lint pass keeps the import;
         # they're needed for the delegate class above.
         _ = (SEL, objc_method)
     except Exception:

pythonnative/native_modules/haptics.py

@@ -2,11 +2,11 @@
 
 Two interfaces live here:
 
-- [`Haptics`][pythonnative.Haptics] — semantic, iOS-style feedback
+- [`Haptics`][pythonnative.Haptics]: semantic, iOS-style feedback
   (impact / notification / selection) backed by
   ``UIFeedbackGenerator`` on iOS and ``VibrationEffect`` patterns on
   Android.
-- [`Vibration`][pythonnative.Vibration] — a blunt "buzz for N
+- [`Vibration`][pythonnative.Vibration]: a blunt "buzz for N
   milliseconds" interface for cases where you want an explicit
   duration.
 

pythonnative/native_modules/location.py

@@ -167,7 +167,7 @@ def _android_get(on_result: Callable[[Optional[Coords]], None]) -> None:
         Context = jclass("android.content.Context")
         lm = ctx.getSystemService(Context.LOCATION_SERVICE)
 
-        # Try the most recent known fix first — it's instant and avoids
+        # Try the most recent known fix first; it's instant and avoids
         # the GPS warm-up delay.
         try:
             for provider in ("gps", "network", "passive"):

pythonnative/native_modules/permissions.py

@@ -3,9 +3,9 @@
 [`Permissions`][pythonnative.Permissions] normalizes the very different
 iOS and Android permission models behind two calls:
 
-- ``check(permission)`` — synchronous, returns a status string without
+- ``check(permission)``: synchronous, returns a status string without
   prompting.
-- ``request(permission)`` — a coroutine that shows the system prompt
+- ``request(permission)``: a coroutine that shows the system prompt
   (if needed) and resolves to the resulting status.
 
 Statuses are ``"granted"``, ``"denied"``, ``"blocked"`` (denied with

pythonnative/native_modules/secure_store.py

@@ -1,7 +1,7 @@
 """Encrypted key/value storage for secrets (tokens, credentials).
 
 [`SecureStore`][pythonnative.SecureStore] persists small string values
-in the iOS Keychain and Android ``EncryptedSharedPreferences`` — the
+in the iOS Keychain and Android ``EncryptedSharedPreferences``, the
 right place for auth tokens and other secrets that
 [`AsyncStorage`][pythonnative.AsyncStorage] (plain, unencrypted) should
 never hold.

pythonnative/native_views/android.py

@@ -8,7 +8,7 @@ and frame application. Handlers are registered with the
 
 **Batched protocol**: the registry applies the reconciler's mutation
 ops; handlers receive callable-free props. User callbacks never reach
-this module — every interaction (clicks, text changes, scrolls,
+this module; every interaction (clicks, text changes, scrolls,
 gestures) is forwarded through
 [`dispatch_event`][pythonnative.events.dispatch_event] keyed by the
 view's reconciler-assigned tag.
@@ -244,7 +244,7 @@ def _apply_accessibility(view: Any, props: Dict[str, Any]) -> None:
         except Exception:
             pass
     # Android's accessibility role / hint mostly comes through
-    # AccessibilityNodeInfo — full plumbing is non-trivial. We keep
+    # AccessibilityNodeInfo; full plumbing is non-trivial. We keep
     # the API surface symmetrical with iOS but apply only the label
     # for now.
 
@@ -689,7 +689,7 @@ class AndroidViewHandler(ViewHandler):
 
 
 class FlexContainerHandler(AndroidViewHandler):
-    """Container for flex layout — a bare `FrameLayout`.
+    """Container for flex layout, a bare `FrameLayout`.
 
     All flex semantics (direction, alignment, distribution, padding)
     are computed by the layout engine and applied via
@@ -844,7 +844,7 @@ class ButtonHandler(AndroidViewHandler):
 
 
 class ScrollViewHandler(AndroidViewHandler):
-    """Scroll container — wraps a single child whose height is unbounded.
+    """Scroll container: wraps a single child whose height is unbounded.
 
     Uses ``androidx.core.widget.NestedScrollView`` (vertical) or
     ``android.widget.HorizontalScrollView`` so nested scroll views
@@ -871,7 +871,7 @@ class ScrollViewHandler(AndroidViewHandler):
                 sv = jclass("android.widget.ScrollView")(_ctx())
 
         # Vertical scroll views are *always* wrapped in a (disabled)
-        # SwipeRefreshLayout. Wrapping later is impossible — the
+        # SwipeRefreshLayout. Wrapping later is impossible; the
         # reconciler may reuse this view for a screen that adds a
         # ``refresh_control`` prop afterwards (e.g. navigation swapping
         # screens of the same shape), and re-parenting a mounted view
@@ -1214,7 +1214,7 @@ class TextInputHandler(AndroidViewHandler):
             # Map the cross-platform ``return_key_type`` to Android's
             # ``EditorInfo.IME_ACTION_*`` so the soft keyboard renders the
             # right action key. iOS has a richer set (Google / Yahoo /
-            # Join / Route) with no direct AOSP equivalents — fall back
+            # Join / Route) with no direct AOSP equivalents; fall back
             # to ``IME_ACTION_DONE`` for those.
             try:
                 EditorInfo = jclass("android.view.inputmethod.EditorInfo")
@@ -1244,7 +1244,7 @@ class TextInputHandler(AndroidViewHandler):
         Single-line inputs always dismiss the keyboard on the action
         key (matching React Native's Android default) and fire
         ``on_submit`` first. Multi-line inputs only consume the action
-        when an ``on_submit`` handler exists — otherwise Enter inserts
+        when an ``on_submit`` handler exists; otherwise Enter inserts
         a newline.
         """
         try:
@@ -1616,7 +1616,7 @@ class WebViewHandler(AndroidViewHandler):
 class SpacerHandler(AndroidViewHandler):
     """Empty layout placeholder used as a flexible gap.
 
-    All sizing semantics live in the layout engine — ``Spacer``
+    All sizing semantics live in the layout engine; ``Spacer``
     behaves identically to a `View` with the same style props (e.g.,
     ``flex: 1`` for an expanding spacer, ``size`` for a fixed gap).
     """
@@ -1638,7 +1638,7 @@ class SafeAreaViewHandler(FlexContainerHandler):
 
 
 # ======================================================================
-# Modal — actually presents a Dialog with the children inside
+# Modal: actually presents a Dialog with the children inside
 # ======================================================================
 
 
@@ -1959,7 +1959,7 @@ class TabBarHandler(AndroidViewHandler):
 
 
 # ======================================================================
-# Pressable — visual feedback + tap callbacks + gestures
+# Pressable: visual feedback + tap callbacks + gestures
 # ======================================================================
 
 
@@ -2073,7 +2073,7 @@ class PressableHandler(FlexContainerHandler):
 
 
 # ======================================================================
-# StatusBar — global side effect
+# StatusBar: global side effect
 # ======================================================================
 
 
@@ -2131,7 +2131,7 @@ def _present_alert(
 ) -> None:
     """Present an AlertDialog or BottomSheet (``style='action_sheet'``).
 
-    Safe to call from any thread — the AlertDialog work is automatically
+    Safe to call from any thread; the AlertDialog work is automatically
     marshalled to the main looper via
     [`pythonnative.runtime.call_on_main_thread`][pythonnative.runtime.call_on_main_thread].
     Returns immediately; the dialog appears on the next main-loop tick.
@@ -2227,12 +2227,12 @@ def _present_alert(
 
 
 # ======================================================================
-# Picker — native dropdown / select widget
+# Picker: native dropdown / select widget
 # ======================================================================
 
 
 class PickerHandler(AndroidViewHandler):
-    """``Picker`` element handler — native ``Spinner`` dropdown."""
+    """``Picker`` element handler, native ``Spinner`` dropdown."""
 
     def _build(self, props: Dict[str, Any]) -> Any:
         sp = jclass("android.widget.Spinner")(_ctx())
@@ -2300,12 +2300,12 @@ class PickerHandler(AndroidViewHandler):
 
 
 # ======================================================================
-# Checkbox — native CheckBox with an optional inline label
+# Checkbox: native CheckBox with an optional inline label
 # ======================================================================
 
 
 class CheckboxHandler(AndroidViewHandler):
-    """``Checkbox`` element handler — native ``CheckBox`` widget.
+    """``Checkbox`` element handler, native ``CheckBox`` widget.
 
     Programmatic ``value`` updates are wrapped in a per-view
     "suppress" guard so pushing a new state via ``setChecked`` never
@@ -2348,12 +2348,12 @@ class CheckboxHandler(AndroidViewHandler):
 
 
 # ======================================================================
-# SegmentedControl — horizontal toggle row (no UISegmentedControl on AOSP)
+# SegmentedControl: horizontal toggle row (no UISegmentedControl on AOSP)
 # ======================================================================
 
 
 class SegmentedControlHandler(AndroidViewHandler):
-    """``SegmentedControl`` element — a horizontal row of toggle buttons.
+    """``SegmentedControl`` element, a horizontal row of toggle buttons.
 
     Android has no ``UISegmentedControl`` equivalent, so the control is
     built from a horizontal ``LinearLayout`` holding one ``Button`` per
@@ -2492,12 +2492,12 @@ class SegmentedControlHandler(AndroidViewHandler):
 
 
 # ======================================================================
-# DatePicker — trigger button opening native date/time dialogs
+# DatePicker: trigger button opening native date/time dialogs
 # ======================================================================
 
 
 class DatePickerHandler(AndroidViewHandler):
-    """``DatePicker`` element — a trigger ``Button`` opening native dialogs.
+    """``DatePicker`` element, a trigger ``Button`` opening native dialogs.
 
     The button text reflects the current ISO ``value`` (or a
     placeholder). Tapping it opens a ``DatePickerDialog`` (``mode``

pythonnative/native_views/base.py

@@ -23,7 +23,7 @@ class ViewHandler:
 
     A `ViewHandler` knows how to create, update, re-parent, and destroy
     native views of one element type. The reconciler never calls a
-    handler directly — it emits a batch of mutation ops
+    handler directly; it emits a batch of mutation ops
     (`pythonnative.mutations`) that the
     [`NativeViewRegistry`][pythonnative.native_views.NativeViewRegistry]
     applies by dispatching to handlers. Handlers never need to know
@@ -132,7 +132,7 @@ class ViewHandler:
 
         The default implementation returns ``(0, 0)``; override for
         leaves whose size depends on their content. Container handlers
-        leave this alone — the engine sizes containers by laying out
+        leave this alone; the engine sizes containers by laying out
         their children.
 
         Args:
@@ -149,7 +149,7 @@ class ViewHandler:
         """Execute an imperative command (e.g. ``"scroll_to_offset"``).
 
         Commands are the escape hatch for one-shot imperative actions
-        that don't fit declarative props — scrolling, focusing,
+        that don't fit declarative props: scrolling, focusing,
         flashing indicators. Unknown commands should be ignored.
 
         Args:

pythonnative/native_views/desktop.py

@@ -74,7 +74,7 @@ from .base import ViewHandler
 # ``pn preview`` installs it before mounting the app; the placement
 # logic (``_place``) positions widgets *inside* their logical parent via
 # Tk's ``-in`` option, which only works when both windows share a
-# top-level — guaranteed by the single-stage design.
+# top-level, guaranteed by the single-stage design.
 
 _ROOT_CONTAINER: Any = None
 _DEFAULT_FONT_SIZE = 15
@@ -125,7 +125,7 @@ def _tk_color(value: Any) -> Optional[str]:
     """Convert a PythonNative color into a Tk color string.
 
     Accepts ``#rgb`` / ``#rrggbb`` / ``#aarrggbb`` hex (alpha is
-    dropped — Tk has no per-color alpha), ``rgb()`` / ``rgba()``
+    dropped; Tk has no per-color alpha), ``rgb()`` / ``rgba()``
     functional notation, ``(r, g, b)`` tuples, packed integers, and
     named colors (passed through for Tk to resolve). Returns ``None``
     for ``transparent`` / unparseable values so callers can leave the
@@ -686,8 +686,8 @@ class ScrollViewHandler(FlexContainerHandler):
 
     The layout engine lets the content grow past the viewport on the
     scroll axis; this handler offsets its children's placement by the
-    current scroll offset (overflow outside the frame is *not* clipped
-    — a documented preview limitation of the single-stage design).
+    current scroll offset (overflow outside the frame is *not* clipped,
+    a documented preview limitation of the single-stage design).
 
     Commands:
         ``scroll_to_offset(x=…, y=…)``: jump to an offset.
@@ -1232,7 +1232,7 @@ class PressableHandler(DesktopViewHandler):
 
 
 class ModalHandler(DesktopViewHandler):
-    """Overlay modal — a frame that fills the stage when ``visible``.
+    """Overlay modal, a frame that fills the stage when ``visible``.
 
     The reconciler lays the modal's content out against the full
     viewport (see ``Reconciler._layout_visible_modals``) and applies
@@ -1275,7 +1275,7 @@ class ModalHandler(DesktopViewHandler):
 
 
 class TabBarHandler(DesktopViewHandler):
-    """Bottom tab bar — a row of buttons laid out across its width."""
+    """Bottom tab bar, a row of buttons laid out across its width."""
 
     def build(self, props: Dict[str, Any]) -> Any:
         frame = tk.Frame(_master(), highlightthickness=1, bd=0, background="#f2f2f7")
@@ -1454,7 +1454,7 @@ class SegmentedControlHandler(DesktopViewHandler):
 
 
 class DatePickerHandler(DesktopViewHandler):
-    """Preview DatePicker — a text entry for the ISO date/time string."""
+    """Preview DatePicker, a text entry for the ISO date/time string."""
 
     def build(self, props: Dict[str, Any]) -> Any:
         entry = tk.Entry(_master(), highlightthickness=1, bd=0)