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

pythonnative/native_modules/__init__.py

@@ -43,6 +43,8 @@ Reactive state (with hooks):
   [`use_net_info`][pythonnative.use_net_info]: connectivity.
 """
 
+from typing import Any, Sequence
+
 from .app_state import AppState, use_app_state
 from .battery import Battery
 from .biometrics import Biometrics
@@ -58,6 +60,25 @@ from .permissions import Permissions
 from .secure_store import SecureStore
 from .share import Share
 
+
+def dispatch_activity_result(request_code: int, result_code: int, data: Any) -> bool:
+    """Route an Android ``onActivityResult`` to whichever module is waiting on it.
+
+    Called by the screen host. Returns ``True`` when a pending request
+    consumed the result.
+    """
+    from .camera import deliver_android_activity_result
+
+    return deliver_android_activity_result(request_code, result_code, data)
+
+
+def dispatch_permissions_result(request_code: int, permissions: Sequence[str], grant_results: Sequence[int]) -> bool:
+    """Route an Android ``onRequestPermissionsResult`` to the pending ``Permissions.request``."""
+    from .permissions import deliver_android_permission_result
+
+    return deliver_android_permission_result(request_code, permissions, grant_results)
+
+
 __all__ = [
     "AppState",
     "Battery",
@@ -74,6 +95,8 @@ __all__ = [
     "SecureStore",
     "Share",
     "Vibration",
+    "dispatch_activity_result",
+    "dispatch_permissions_result",
     "use_app_state",
     "use_net_info",
 ]

pythonnative/native_modules/net_info.py

@@ -151,7 +151,11 @@ def use_net_info() -> NetInfoState:
 
     def _subscribe() -> Callable[[], None]:
         set_state(NetInfo.fetch())
-        return NetInfo.add_listener(set_state)
+
+        def on_change(snapshot: NetInfoState) -> None:
+            set_state(snapshot)
+
+        return NetInfo.add_listener(on_change)
 
     use_effect(_subscribe, [])
     return state

pythonnative/native_views/__init__.py

@@ -220,7 +220,7 @@ class NativeViewRegistry:
         if not finite:
             _tripwire_log(
                 "set_frame:nan",
-                f"[set_frame:nan] type={record.type_name!r} " f"x={op.x!r} y={op.y!r} w={op.width!r} h={op.height!r}",
+                f"[set_frame:nan] type={record.type_name!r} x={op.x!r} y={op.y!r} w={op.width!r} h={op.height!r}",
             )
         record.handler.set_frame(record.view, op.x, op.y, op.width, op.height)
 

pythonnative/native_views/android.py

@@ -60,7 +60,15 @@ from .. import diagnostics
 from ..events import dispatch_event, event_names
 from ..gestures import make_arbiter
 from ..utils import get_android_context
-from .base import ViewHandler, _safe_max, parse_color_int
+from .base import (
+    TEXT_SHADOW_STYLE_KEYS,
+    ViewHandler,
+    _safe_max,
+    parse_color_int,
+    shadow_offset_xy,
+    transform_spans,
+    transform_text,
+)
 
 _SIDE_BORDER_WIDTH_KEYS = (
     "border_left_width",
@@ -676,6 +684,15 @@ def _apply_common_visual(view: Any, props: Dict[str, Any]) -> None:
             view.setClipToPadding(clip)
         except Exception:
             diagnostics.swallowed("android._apply_common_visual")
+    if "display" in props:
+        # Layout already zeroes the subtree; ``INVISIBLE`` (not ``GONE``,
+        # since Python owns layout) also drops it from touch delivery and
+        # the accessibility tree (inactive tabs, covered stack screens).
+        try:
+            View = jclass("android.view.View")
+            view.setVisibility(View.INVISIBLE if props["display"] == "none" else View.VISIBLE)
+        except Exception:
+            diagnostics.swallowed("android._apply_common_visual")
     if "opacity" in props and props["opacity"] is not None:
         try:
             view.setAlpha(float(props["opacity"]))
@@ -1305,21 +1322,21 @@ class TextHandler(AndroidViewHandler):
         return jclass("android.widget.TextView")(_ctx())
 
     def _apply(self, tv: Any, props: Dict[str, Any], initial: bool) -> None:
-        if "spans" in props or "text" in props:
+        if "spans" in props or "text" in props or "text_transform" in props:
             # ``update()`` merges changed props into the view state
             # before calling ``_apply``, so the merged dict always has
             # the latest text/spans pair (covering rich -> plain
             # transitions where only ``spans`` changed).
             merged = _state_of(tv).get("props") or props
+            transform = merged.get("text_transform")
             spans = merged.get("spans")
             if spans:
                 try:
-                    tv.setText(_build_spannable(spans))
+                    tv.setText(_build_spannable(transform_spans(spans, transform)))
                 except Exception:
-                    tv.setText(str(merged.get("text") or ""))
+                    tv.setText(transform_text(merged.get("text"), transform))
             else:
-                text = merged.get("text")
-                tv.setText(str(text) if text is not None else "")
+                tv.setText(transform_text(merged.get("text"), transform))
         if "font_size" in props and props["font_size"] is not None:
             tv.setTextSize(float(props["font_size"]))
         if "color" in props and props["color"] is not None:
@@ -1372,8 +1389,35 @@ class TextHandler(AndroidViewHandler):
                 tv.setPaintFlags(flags)
             except Exception:
                 diagnostics.swallowed("android.TextHandler._apply")
+        if any(k in props for k in TEXT_SHADOW_STYLE_KEYS):
+            self._apply_text_shadow(tv, _state_of(tv).get("props") or props)
         _apply_common_visual(tv, props)
 
+    @staticmethod
+    def _apply_text_shadow(tv: Any, merged: Dict[str, Any]) -> None:
+        """Map the ``text_shadow_*`` keys onto ``TextView.setShadowLayer``.
+
+        The offset and radius are in dp (converted to pixels like every
+        other length); the platform disables the shadow when every
+        parameter is zero, which is also what clearing the keys does.
+        """
+        try:
+            if not any(merged.get(k) is not None for k in TEXT_SHADOW_STYLE_KEYS):
+                tv.setShadowLayer(0.0, 0.0, 0.0, 0)
+                return
+            color = merged.get("text_shadow_color")
+            argb = parse_color_int(color if color is not None else "#000000")
+            dx, dy = shadow_offset_xy(merged.get("text_shadow_offset"))
+            radius = merged.get("text_shadow_radius")
+            radius_px = float(_dp(float(radius))) if radius is not None else 0.0
+            # A zero radius with a non-zero offset would hide the shadow
+            # on some renderers; use a hairline blur so it still draws.
+            if radius_px <= 0.0 and (dx or dy):
+                radius_px = 0.01
+            tv.setShadowLayer(radius_px, float(_dp(dx)), float(_dp(dy)), argb)
+        except Exception:
+            diagnostics.swallowed("android.TextHandler._apply_text_shadow")
+
 
 class ButtonHandler(AndroidViewHandler):
     def _build(self, props: Dict[str, Any]) -> Any:

pythonnative/native_views/base.py

@@ -15,7 +15,8 @@ for content-sized leaves (text, buttons, images).
 """
 
 import math
-from typing import Any, Dict, Tuple, Union
+import re
+from typing import Any, Dict, Optional, Tuple, Union
 
 
 class ViewHandler:
@@ -241,6 +242,68 @@ def parse_color_int(color: Union[str, int]) -> int:
     return val
 
 
+# ======================================================================
+# Text helpers shared by every backend's Text handler
+# ======================================================================
+
+_WORD_START = re.compile(r"(?<!\S)(\S)")
+
+
+def transform_text(text: Any, mode: Optional[str]) -> str:
+    """Apply a ``text_transform`` style value to ``text``.
+
+    Runs in Python before the string is handed to the native label, so
+    the displayed text and the intrinsic measurement agree on every
+    backend. ``"capitalize"`` upper-cases the first character of each
+    whitespace-separated word and leaves the rest untouched (matching
+    CSS / React Native rather than ``str.title()``, which would
+    lower-case the remainder). Unknown modes and ``"none"`` return the
+    text unchanged.
+    """
+    s = "" if text is None else str(text)
+    if mode == "uppercase":
+        return s.upper()
+    if mode == "lowercase":
+        return s.lower()
+    if mode == "capitalize":
+        return _WORD_START.sub(lambda m: m.group(1).upper(), s)
+    return s
+
+
+def transform_spans(spans: Any, mode: Optional[str]) -> Any:
+    """Return ``spans`` with `transform_text` applied to each span's ``text``.
+
+    Rich text is flattened into one native string, so a run-by-run
+    transform matches what a single-string transform would produce for
+    ``uppercase`` / ``lowercase``. ``capitalize`` is evaluated per span,
+    which is also how CSS treats inline boxes.
+    """
+    if not mode or mode == "none" or not isinstance(spans, list):
+        return spans
+    out = []
+    for span in spans:
+        if isinstance(span, dict) and "text" in span:
+            copy = dict(span)
+            copy["text"] = transform_text(span.get("text"), mode)
+            out.append(copy)
+        else:
+            out.append(span)
+    return out
+
+
+def shadow_offset_xy(value: Any) -> Tuple[float, float]:
+    """Coerce a ``shadow_offset`` / ``text_shadow_offset`` value to ``(dx, dy)``."""
+    if isinstance(value, dict):
+        return (float(value.get("width", 0) or 0), float(value.get("height", 0) or 0))
+    if isinstance(value, (tuple, list)) and len(value) >= 2:
+        return (float(value[0]), float(value[1]))
+    return (0.0, 0.0)
+
+
+TEXT_SHADOW_STYLE_KEYS = ("text_shadow_color", "text_shadow_offset", "text_shadow_radius")
+"""Style keys that together describe a text shadow."""
+
+
 # ======================================================================
 # Helpers shared by Android and iOS measure callbacks
 # ======================================================================

pythonnative/native_views/desktop.py

@@ -96,7 +96,7 @@ from typing import Any, Dict, List, Optional, Tuple
 from .. import diagnostics
 from ..events import dispatch_event, event_names
 from ..gestures import make_arbiter
-from .base import ViewHandler
+from .base import ViewHandler, transform_text
 
 # ======================================================================
 # Stage / root container
@@ -1452,13 +1452,21 @@ _JUSTIFY_FOR_ALIGN = {"left": "left", "center": "center", "right": "right"}
 
 
 class TextHandler(DesktopViewHandler):
+    """Tk ``Label`` text leaf.
+
+    ``text_transform`` is applied to the string before it is stored, so
+    ``measure_intrinsic`` and the rendered label agree. The
+    ``text_shadow_*`` keys are accepted but ignored: Tk has no text
+    shadow primitive, and the preview stays faithful to layout rather
+    than approximating one with a second label.
+    """
+
     def build(self, props: Dict[str, Any]) -> Any:
         return tk.Label(_master(), highlightthickness=0, bd=0, padx=0, pady=0)
 
     def apply(self, label: Any, props: Dict[str, Any]) -> None:
         merged = getattr(label, "_pn_props", props)
-        text = merged.get("text")
-        label._pn_text = "" if text is None else str(text)
+        label._pn_text = transform_text(merged.get("text"), merged.get("text_transform"))
         font = _make_font(merged)
         label._pn_font = font
         opts: Dict[str, Any] = {"text": label._pn_text, "font": font}

pythonnative/native_views/ios.py

@@ -63,7 +63,15 @@ from rubicon.objc import SEL, ObjCClass, ObjCInstance, objc_method
 from .. import diagnostics
 from ..events import dispatch_event, event_names
 from . import _tripwire_log
-from .base import ViewHandler, _safe_max, parse_color_int
+from .base import (
+    TEXT_SHADOW_STYLE_KEYS,
+    ViewHandler,
+    _safe_max,
+    parse_color_int,
+    shadow_offset_xy,
+    transform_spans,
+    transform_text,
+)
 
 
 def _safe_finite(value: Any, default: float = 0.0) -> float:
@@ -624,6 +632,30 @@ def _apply_shadow(view: Any, props: Dict[str, Any]) -> None:
             diagnostics.swallowed("ios._apply_shadow")
 
 
+def _text_shadow(props: Dict[str, Any]) -> Any:
+    """Build an ``NSShadow`` from the ``text_shadow_*`` style keys, or ``None``.
+
+    Text shadows are attached to the attributed string
+    (``NSShadowAttributeName``) rather than the label's layer so they
+    follow the glyphs instead of the label's frame and don't interfere
+    with the view-level ``shadow_*`` props.
+    """
+    if not any(props.get(k) is not None for k in TEXT_SHADOW_STYLE_KEYS):
+        return None
+    try:
+        shadow = ObjCClass("NSShadow").alloc().init()
+        color = props.get("text_shadow_color")
+        shadow.setShadowColor_(_uicolor(color if color is not None else "#000000"))
+        dx, dy = shadow_offset_xy(props.get("text_shadow_offset"))
+        shadow.setShadowOffset_((dx, dy))
+        radius = props.get("text_shadow_radius")
+        shadow.setShadowBlurRadius_(float(radius) if radius is not None else 0.0)
+        return shadow
+    except Exception:
+        diagnostics.swallowed("ios._text_shadow")
+        return None
+
+
 def _make_transform(spec: Any) -> Any:
     """Build a `CGAffineTransform` from a list of transform dicts.
 
@@ -821,6 +853,14 @@ def _apply_common_visual(view: Any, props: Dict[str, Any]) -> None:
             diagnostics.swallowed("ios._apply_common_visual")
     if "overflow" in props:
         view.setClipsToBounds_(props["overflow"] == "hidden")
+    if "display" in props:
+        # Layout already zeroes the subtree; hiding also removes it from
+        # hit testing and the accessibility tree (inactive tabs, covered
+        # stack screens).
+        try:
+            view.setHidden_(props["display"] == "none")
+        except Exception:
+            diagnostics.swallowed("ios._apply_common_visual")
     if "opacity" in props and props["opacity"] is not None:
         try:
             view.setAlpha_(float(props["opacity"]))
@@ -1969,25 +2009,32 @@ class TextHandler(IOSViewHandler):
                 diagnostics.swallowed("ios.TextHandler._font_for")
         return font
 
+    # Keys that need the plain string re-rendered as an attributed
+    # string (plain ``setText_`` can't express them).
+    _ATTRIBUTED_KEYS = (
+        "letter_spacing",
+        "line_height",
+        "text_decoration",
+    ) + TEXT_SHADOW_STYLE_KEYS
+
     _SPAN_REBUILD_KEYS = (
         "spans",
         "text",
+        "text_transform",
         "font_size",
         "font_weight",
         "font_family",
         "italic",
         "bold",
         "color",
-        "letter_spacing",
-        "line_height",
-        "text_decoration",
-    )
+    ) + _ATTRIBUTED_KEYS
 
     def _apply(self, label: Any, props: Dict[str, Any], initial: bool) -> None:
         merged_state = _state_of(label).get("props") or props
         has_spans = bool(merged_state.get("spans"))
-        if "text" in props and not has_spans:
-            label.setText_(str(props["text"]) if props["text"] is not None else "")
+        text_changed = "text" in props or "text_transform" in props
+        if text_changed and not has_spans:
+            label.setText_(transform_text(merged_state.get("text"), merged_state.get("text_transform")))
         # Font requires combining size + weight + family + italic + bold.
         font_keys_present = any(k in props for k in ("font_size", "font_weight", "font_family", "italic", "bold"))
         if font_keys_present:
@@ -2018,8 +2065,13 @@ class TextHandler(IOSViewHandler):
                 self._apply_spans(label, merged_state)
         elif "spans" in props:
             # Rich -> plain transition: restore the plain string.
-            label.setText_(str(merged_state.get("text") or ""))
-        elif "letter_spacing" in props or "line_height" in props or "text_decoration" in props:
+            label.setText_(transform_text(merged_state.get("text"), merged_state.get("text_transform")))
+        elif any(k in props for k in self._ATTRIBUTED_KEYS) or (
+            # ``setText_`` drops attributes, so a text change re-renders
+            # the attributed string when any attributed key is active.
+            text_changed
+            and any(merged_state.get(k) is not None for k in self._ATTRIBUTED_KEYS)
+        ):
             self._apply_attributed(label, merged_state)
         _apply_view_border(label, props)
         _apply_shadow(label, props)
@@ -2041,6 +2093,7 @@ class TextHandler(IOSViewHandler):
         """
         try:
             spans = [s for s in (merged.get("spans") or []) if isinstance(s, dict)]
+            spans = transform_spans(spans, merged.get("text_transform"))
             full_text = "".join(str(s.get("text", "")) for s in spans)
             NSMutableAttributedString = ObjCClass("NSMutableAttributedString")
             NSMutableParagraphStyle = ObjCClass("NSMutableParagraphStyle")
@@ -2062,6 +2115,9 @@ class TextHandler(IOSViewHandler):
                 attr.addAttribute_value_range_("NSUnderline", 1, full_range)
             elif merged.get("text_decoration") == "line_through":
                 attr.addAttribute_value_range_("NSStrikethrough", 1, full_range)
+            shadow = _text_shadow(merged)
+            if shadow is not None:
+                attr.addAttribute_value_range_("NSShadow", shadow, full_range)
 
             pos = 0
             for span in spans:
@@ -2095,7 +2151,7 @@ class TextHandler(IOSViewHandler):
             label.setAttributedText_(attr)
         except Exception:
             try:
-                label.setText_(str(merged.get("text") or ""))
+                label.setText_(transform_text(merged.get("text"), merged.get("text_transform")))
             except Exception:
                 diagnostics.swallowed("ios.TextHandler._apply_spans")
 
@@ -2103,8 +2159,9 @@ class TextHandler(IOSViewHandler):
         """Re-render the label's text as an NSAttributedString.
 
         Needed for ``letter_spacing`` (NSKernAttributeName),
-        ``line_height`` (paragraph style), and ``text_decoration``
-        (underline/strikethrough). Plain text setters do not support
+        ``line_height`` (paragraph style), ``text_decoration``
+        (underline/strikethrough), and the ``text_shadow_*`` keys
+        (NSShadowAttributeName). Plain text setters do not support
         these attributes.
         """
         try:
@@ -2140,6 +2197,9 @@ class TextHandler(IOSViewHandler):
                 attr.addAttribute_value_range_("NSUnderline", 1, full_range)
             elif decoration == "line_through":
                 attr.addAttribute_value_range_("NSStrikethrough", 1, full_range)
+            shadow = _text_shadow(props)
+            if shadow is not None:
+                attr.addAttribute_value_range_("NSShadow", shadow, full_range)
             label.setAttributedText_(attr)
         except Exception:
             diagnostics.swallowed("ios.TextHandler._apply_attributed")

pythonnative/navigation/__init__.py

@@ -0,0 +1,102 @@
+"""Navigation: stack, tab, and drawer navigators with a React Navigation-style API.
+
+```python
+import pythonnative as pn
+
+Stack = pn.create_stack_navigator()
+
+@pn.component
+def HomeScreen():
+    nav = pn.use_navigation()
+    return pn.Button("Open 42", on_press=lambda: nav.navigate("Detail", id=42))
+
+@pn.component
+def DetailScreen():
+    route = pn.use_route()
+    return pn.Text(f"Item {route.params['id']}")
+
+@pn.component
+def App():
+    return pn.NavigationContainer(
+        Stack.Navigator(
+            Stack.Screen("Home", HomeScreen, title="Home"),
+            Stack.Screen("Detail", DetailScreen, options=lambda route: {"title": f"Item {route.params['id']}"}),
+        )
+    )
+```
+
+Public surface (all re-exported from ``pythonnative``):
+
+- Factories: [`create_stack_navigator`][pythonnative.create_stack_navigator],
+  [`create_tab_navigator`][pythonnative.create_tab_navigator],
+  [`create_drawer_navigator`][pythonnative.create_drawer_navigator],
+  [`NavigationContainer`][pythonnative.NavigationContainer].
+- Hooks: [`use_navigation`][pythonnative.use_navigation],
+  [`use_route`][pythonnative.use_route],
+  [`use_is_focused`][pythonnative.use_is_focused],
+  [`use_focus_effect`][pythonnative.use_focus_effect].
+- Types: [`Navigation`][pythonnative.Navigation],
+  [`Route`][pythonnative.navigation.Route],
+  [`NavigationState`][pythonnative.navigation.NavigationState],
+  [`ScreenOptions`][pythonnative.ScreenOptions],
+  [`LinkingConfig`][pythonnative.LinkingConfig].
+"""
+
+from .container import ContainerContext, NavigationContainer
+from .handle import (
+    DrawerNavigation,
+    EventName,
+    FocusContext,
+    HostNavigator,
+    Navigation,
+    NavigationContext,
+    NavigationEvent,
+    NavigatorCore,
+    TabNavigation,
+)
+from .hooks import use_focus_effect, use_is_focused, use_navigation, use_route
+from .host import NAV_STATE_ARG, HostContext, HostRoot
+from .linking import LinkingConfig
+from .navigators import (
+    DrawerNavigator,
+    StackNavigator,
+    TabNavigator,
+    create_drawer_navigator,
+    create_stack_navigator,
+    create_tab_navigator,
+)
+from .screen import HeaderSlot, ScreenDef, ScreenOptions
+from .state import NavigationState, Route
+
+__all__ = [
+    "NAV_STATE_ARG",
+    "ContainerContext",
+    "DrawerNavigation",
+    "DrawerNavigator",
+    "EventName",
+    "FocusContext",
+    "HeaderSlot",
+    "HostContext",
+    "HostNavigator",
+    "HostRoot",
+    "LinkingConfig",
+    "Navigation",
+    "NavigationContainer",
+    "NavigationContext",
+    "NavigationEvent",
+    "NavigationState",
+    "NavigatorCore",
+    "Route",
+    "ScreenDef",
+    "ScreenOptions",
+    "StackNavigator",
+    "TabNavigation",
+    "TabNavigator",
+    "create_drawer_navigator",
+    "create_stack_navigator",
+    "create_tab_navigator",
+    "use_focus_effect",
+    "use_is_focused",
+    "use_navigation",
+    "use_route",
+]