pythonnative 0.7.0__tar.gz → 0.9.0__tar.gz

{pythonnative-0.7.0/src/pythonnative.egg-info → pythonnative-0.9.0}/PKG-INFO

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

{pythonnative-0.7.0 → pythonnative-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.7.0"
+version = "0.9.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }

{pythonnative-0.7.0 → pythonnative-0.9.0}/src/pythonnative/__init__.py

@@ -14,12 +14,13 @@ Public API::
         )
 """
 
-__version__ = "0.7.0"
+__version__ = "0.9.0"
 
 from .components import (
     ActivityIndicator,
     Button,
     Column,
+    ErrorBoundary,
     FlatList,
     Image,
     Modal,
@@ -39,6 +40,7 @@ from .components import (
 from .element import Element
 from .hooks import (
     Provider,
+    batch_updates,
     component,
     create_context,
     use_callback,
@@ -46,9 +48,18 @@ from .hooks import (
     use_effect,
     use_memo,
     use_navigation,
+    use_reducer,
     use_ref,
     use_state,
 )
+from .navigation import (
+    NavigationContainer,
+    create_drawer_navigator,
+    create_stack_navigator,
+    create_tab_navigator,
+    use_focus_effect,
+    use_route,
+)
 from .page import create_page
 from .style import StyleSheet, ThemeContext
 
@@ -57,6 +68,7 @@ __all__ = [
     "ActivityIndicator",
     "Button",
     "Column",
+    "ErrorBoundary",
     "FlatList",
     "Image",
     "Modal",
@@ -76,16 +88,25 @@ __all__ = [
     "Element",
     "create_page",
     # Hooks
+    "batch_updates",
     "component",
     "create_context",
     "use_callback",
     "use_context",
     "use_effect",
+    "use_focus_effect",
     "use_memo",
     "use_navigation",
+    "use_reducer",
     "use_ref",
+    "use_route",
     "use_state",
     "Provider",
+    # Navigation
+    "NavigationContainer",
+    "create_drawer_navigator",
+    "create_stack_navigator",
+    "create_tab_navigator",
     # Styling
     "StyleSheet",
     "ThemeContext",

pythonnative-0.9.0/src/pythonnative/_ios_log.py

@@ -0,0 +1,94 @@
+"""Route Python ``sys.stdout``/``sys.stderr`` through fd 2 on iOS.
+
+Why
+---
+When an app is launched via ``xcrun simctl launch --console-pty`` (what
+``pn run ios`` does), the simulator attaches the caller's terminal to
+the app's stderr, which is the same channel ``NSLog`` / ``os_log``
+writes to. Python ``print()`` calls, however, go to ``sys.stdout``
+(fd 1), and for reasons specific to how CPython's embedded framework
+is started on the iOS Simulator that descriptor does not reach the
+attached console. As a result users see Swift-side ``NSLog`` output
+but never their own ``print()`` output.
+
+Redirecting ``sys.stdout`` / ``sys.stderr`` at a Python level to write
+straight to fd 2 is a small, reliable fix: fd 2 *is* visible to
+``simctl`` (that's exactly how ``NSLog`` reaches the terminal), so
+Python output lands next to the Swift logs with correct ordering.
+
+This module is intentionally self-contained: no rubicon-objc or
+platform-specific C bindings required, so it's safe to import early
+during ``pythonnative`` package initialization.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Iterable
+
+_STDERR_FD = 2
+
+
+class _StderrStream:
+    """Minimal text-mode file-like that writes UTF-8 bytes to fd 2.
+
+    It's write-through (no buffering) so a ``print()`` call appears in
+    the terminal immediately, which matches user expectations for an
+    interactive "run on simulator" log stream.
+    """
+
+    encoding = "utf-8"
+    errors = "replace"
+    mode = "w"
+    name = "<stderr>"
+
+    def write(self, s: str) -> int:
+        if not s:
+            return 0
+        data = s.encode(self.encoding, self.errors)
+        try:
+            return os.write(_STDERR_FD, data)
+        except OSError:
+            return 0
+
+    def writelines(self, lines: Iterable[str]) -> None:
+        for line in lines:
+            self.write(line)
+
+    def flush(self) -> None:
+        # os.write is unbuffered; nothing to flush.
+        return None
+
+    def isatty(self) -> bool:
+        try:
+            return os.isatty(_STDERR_FD)
+        except OSError:
+            return False
+
+    def fileno(self) -> int:
+        return _STDERR_FD
+
+    def close(self) -> None:
+        # Don't actually close fd 2.
+        return None
+
+    @property
+    def closed(self) -> bool:
+        return False
+
+
+_installed = False
+
+
+def install() -> None:
+    """Swap ``sys.stdout`` / ``sys.stderr`` for fd-2 writers.
+
+    Safe to call multiple times; only the first call has effect.
+    """
+    global _installed
+    if _installed:
+        return
+    sys.stdout = _StderrStream()
+    sys.stderr = _StderrStream()
+    _installed = True

{pythonnative-0.7.0 → pythonnative-0.9.0}/src/pythonnative/cli/pn.py

@@ -246,6 +246,55 @@ def _read_requirements(requirements_path: str) -> list[str]:
     return result
 
 
+ANDROID_LOGCAT_FILTERS: list[str] = [
+    "python.stdout:V",
+    "python.stderr:V",
+    "MainActivity:V",
+    "PageFragment:V",
+    "Navigator:V",
+    "PythonNative:V",
+    "AndroidRuntime:E",
+    "System.err:W",
+    "*:S",
+]
+
+IOS_BUNDLE_ID: str = "com.pythonnative.ios-template"
+
+
+def _start_android_log_stream() -> Optional[subprocess.Popen]:
+    """Clear logcat and stream Python-relevant log tags to the terminal.
+
+    Returns the ``adb logcat`` subprocess, or ``None`` when ``adb`` is
+    unavailable. Python's ``print()`` output reaches logcat via Chaquopy,
+    which redirects ``sys.stdout``/``sys.stderr`` to the ``python.stdout``
+    and ``python.stderr`` tags.
+    """
+    try:
+        subprocess.run(["adb", "logcat", "-c"], check=False, capture_output=True)
+    except FileNotFoundError:
+        print("Note: 'adb' not found on PATH; skipping log streaming.")
+        return None
+    try:
+        proc = subprocess.Popen(["adb", "logcat", *ANDROID_LOGCAT_FILTERS])
+    except FileNotFoundError:
+        return None
+    print("Streaming Python logs from device (Ctrl+C to stop)...")
+    return proc
+
+
+def _terminate_subprocess(proc: Optional[subprocess.Popen]) -> None:
+    """Politely stop a subprocess, escalating to SIGKILL if needed."""
+    if proc is None:
+        return
+    if proc.poll() is not None:
+        return
+    proc.terminate()
+    try:
+        proc.wait(timeout=3)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+
+
 def run_project(args: argparse.Namespace) -> None:
     """
     Run the specified project.
@@ -254,6 +303,7 @@ def run_project(args: argparse.Namespace) -> None:
     platform: str = args.platform
     prepare_only: bool = getattr(args, "prepare_only", False)
     hot_reload: bool = getattr(args, "hot_reload", False)
+    show_logs: bool = not getattr(args, "no_logs", False)
 
     # Read project configuration and save project root before any chdir
     project_dir: str = os.getcwd()
@@ -371,6 +421,18 @@ def run_project(args: argparse.Namespace) -> None:
             ],
             check=True,
         )
+
+        # Stream Python logs from logcat unless the user opted out or requested
+        # hot-reload (hot-reload handles its own log tailing below).
+        if show_logs and not hot_reload:
+            logcat_proc = _start_android_log_stream()
+            if logcat_proc is not None:
+                try:
+                    logcat_proc.wait()
+                except KeyboardInterrupt:
+                    print()
+                    _terminate_subprocess(logcat_proc)
+                    print("Stopped log streaming.")
     elif platform == "ios":
         # Attempt to build and run on iOS Simulator (best-effort)
         ios_project_dir: str = os.path.join(build_dir, "ios_template")
@@ -640,22 +702,64 @@ def run_project(args: argparse.Namespace) -> None:
                     return
 
                 udid = preferred.get("udid")
-                # Boot (no-op if already booted)
-                subprocess.run(["xcrun", "simctl", "boot", udid], check=False)
-                # Install and launch
+                # Boot (no-op if already booted). simctl returns non-zero and
+                # prints to stderr when the device is already Booted; we
+                # don't care about that case, so swallow its output.
+                subprocess.run(["xcrun", "simctl", "boot", udid], check=False, capture_output=True)
+                # Install
                 subprocess.run(["xcrun", "simctl", "install", udid, app_path], check=False)
-                subprocess.run(["xcrun", "simctl", "launch", udid, "com.pythonnative.ios-template"], check=False)
-                print("Launched iOS app on Simulator (best-effort).")
+                if show_logs and not hot_reload:
+                    # Attach the app's stdout/stderr to this terminal so Python
+                    # print() calls and exceptions are visible. SIMCTL_CHILD_*
+                    # env vars are forwarded to the launched process.
+                    sim_env = os.environ.copy()
+                    sim_env["SIMCTL_CHILD_PYTHONUNBUFFERED"] = "1"
+                    print("Launched iOS app on Simulator. Streaming logs (Ctrl+C to stop)...")
+                    try:
+                        subprocess.run(
+                            [
+                                "xcrun",
+                                "simctl",
+                                "launch",
+                                "--console-pty",
+                                "--terminate-running-process",
+                                udid,
+                                IOS_BUNDLE_ID,
+                            ],
+                            env=sim_env,
+                            check=False,
+                        )
+                    except KeyboardInterrupt:
+                        print()
+                        subprocess.run(
+                            ["xcrun", "simctl", "terminate", udid, IOS_BUNDLE_ID],
+                            check=False,
+                            capture_output=True,
+                        )
+                        print("Stopped log streaming.")
+                else:
+                    subprocess.run(["xcrun", "simctl", "launch", udid, IOS_BUNDLE_ID], check=False)
+                    print("Launched iOS app on Simulator (best-effort).")
+                    if show_logs and hot_reload:
+                        print(
+                            "Note: live Python log streaming on iOS is disabled while --hot-reload is active; "
+                            "use Console.app or Xcode to view logs."
+                        )
             except Exception:
                 print("Failed to auto-run on Simulator; open the project in Xcode to run.")
 
     # Hot-reload file watcher
     if hot_reload and not prepare_only:
-        _run_hot_reload(platform, project_dir, build_dir)
+        _run_hot_reload(platform, project_dir, build_dir, show_logs=show_logs)
+
 
+def _run_hot_reload(platform: str, project_dir: str, build_dir: str, show_logs: bool = True) -> None:
+    """Watch ``app/`` for changes and push updated files to the device.
 
-def _run_hot_reload(platform: str, project_dir: str, build_dir: str) -> None:
-    """Watch ``app/`` for changes and push updated files to the device."""
+    When ``show_logs`` is true and targeting Android, ``adb logcat`` is
+    streamed in parallel so Python print/exception output stays visible
+    alongside hot-reload notifications.
+    """
     from .hot_reload import FileWatcher
 
     app_dir = os.path.join(project_dir, "app")
@@ -673,12 +777,23 @@ def _run_hot_reload(platform: str, project_dir: str, build_dir: str) -> None:
     print("[hot-reload] Watching app/ for changes. Press Ctrl+C to stop.")
     watcher = FileWatcher(app_dir, on_change, interval=1.0)
     watcher.start()
+
+    logcat_proc: Optional[subprocess.Popen] = None
+    if show_logs and platform == "android":
+        logcat_proc = _start_android_log_stream()
+
     try:
-        import time
+        if logcat_proc is not None:
+            logcat_proc.wait()
+        else:
+            import time
 
-        while True:
-            time.sleep(1)
+            while True:
+                time.sleep(1)
     except KeyboardInterrupt:
+        pass
+    finally:
+        _terminate_subprocess(logcat_proc)
         watcher.stop()
         print("\n[hot-reload] Stopped.")
 
@@ -721,6 +836,11 @@ def main() -> None:
         action="store_true",
         help="Watch app/ for changes and push updates to the running app",
     )
+    parser_run.add_argument(
+        "--no-logs",
+        action="store_true",
+        help="Don't attach to the app's stdout/stderr after launching (default: stream logs)",
+    )
     parser_run.set_defaults(func=run_project)
 
     # Create a new command 'clean' that calls clean_project

{pythonnative-0.7.0 → pythonnative-0.9.0}/src/pythonnative/components.py

@@ -9,12 +9,18 @@ which accepts a dict or a list of dicts (later entries override earlier).
 
 Layout properties supported by all components::
 
-    width, height, flex, margin, min_width, max_width, min_height,
-    max_height, align_self
+    width, height, flex, flex_grow, flex_shrink, margin,
+    min_width, max_width, min_height, max_height, align_self
 
-Container-specific layout properties (Column / Row)::
+Flex container properties (View / Column / Row)::
 
-    spacing, padding, align_items, justify_content
+    flex_direction, justify_content, align_items, overflow,
+    spacing, padding
+
+``View`` is the universal flex container (like React Native's ``View``).
+It defaults to ``flex_direction: "column"``.  ``Column`` and ``Row``
+are convenience wrappers that fix the direction to ``"column"`` and
+``"row"`` respectively.
 """
 
 from typing import Any, Callable, Dict, List, Optional
@@ -204,15 +210,48 @@ def Slider(
 # ======================================================================
 
 
+def View(
+    *children: Element,
+    style: StyleValue = None,
+    key: Optional[str] = None,
+) -> Element:
+    """Universal flex container (like React Native's ``View``).
+
+    Defaults to ``flex_direction: "column"``.  Override via ``style``::
+
+        pn.View(child_a, child_b, style={"flex_direction": "row"})
+
+    Flex container properties (inside ``style``):
+
+    - ``flex_direction`` — ``"column"`` (default), ``"row"``,
+      ``"column_reverse"``, ``"row_reverse"``
+    - ``justify_content`` — main-axis distribution:
+      ``"flex_start"`` (default), ``"center"``, ``"flex_end"``,
+      ``"space_between"``, ``"space_around"``, ``"space_evenly"``
+    - ``align_items`` — cross-axis alignment:
+      ``"stretch"`` (default), ``"flex_start"``, ``"center"``,
+      ``"flex_end"``
+    - ``overflow`` — ``"visible"`` (default) or ``"hidden"``
+    - ``spacing``, ``padding``, ``background_color``
+    """
+    props: Dict[str, Any] = {"flex_direction": "column"}
+    props.update(resolve_style(style))
+    return Element("View", props, list(children), key=key)
+
+
 def Column(
     *children: Element,
     style: StyleValue = None,
     key: Optional[str] = None,
 ) -> Element:
-    """Arrange children vertically.
+    """Arrange children vertically (``flex_direction: "column"``).
+
+    Convenience wrapper around :func:`View`.  The direction is fixed;
+    use :func:`View` directly if you need ``flex_direction: "row"``.
 
     Style properties: ``spacing``, ``padding``, ``align_items``,
-    ``justify_content``, ``background_color``, plus common layout props.
+    ``justify_content``, ``background_color``, ``overflow``,
+    plus common layout props.
 
     ``align_items`` controls cross-axis (horizontal) alignment:
     ``"stretch"`` (default), ``"flex_start"``/``"leading"``,
@@ -222,8 +261,9 @@ def Column(
     ``"flex_start"`` (default), ``"center"``, ``"flex_end"``,
     ``"space_between"``, ``"space_around"``, ``"space_evenly"``.
     """
-    props: Dict[str, Any] = {}
+    props: Dict[str, Any] = {"flex_direction": "column"}
     props.update(resolve_style(style))
+    props["flex_direction"] = "column"
     return Element("Column", props, list(children), key=key)
 
 
@@ -232,10 +272,14 @@ def Row(
     style: StyleValue = None,
     key: Optional[str] = None,
 ) -> Element:
-    """Arrange children horizontally.
+    """Arrange children horizontally (``flex_direction: "row"``).
+
+    Convenience wrapper around :func:`View`.  The direction is fixed;
+    use :func:`View` directly if you need ``flex_direction: "column"``.
 
     Style properties: ``spacing``, ``padding``, ``align_items``,
-    ``justify_content``, ``background_color``, plus common layout props.
+    ``justify_content``, ``background_color``, ``overflow``,
+    plus common layout props.
 
     ``align_items`` controls cross-axis (vertical) alignment:
     ``"stretch"`` (default), ``"flex_start"``/``"top"``,
@@ -245,8 +289,9 @@ def Row(
     ``"flex_start"`` (default), ``"center"``, ``"flex_end"``,
     ``"space_between"``, ``"space_around"``, ``"space_evenly"``.
     """
-    props: Dict[str, Any] = {}
+    props: Dict[str, Any] = {"flex_direction": "row"}
     props.update(resolve_style(style))
+    props["flex_direction"] = "row"
     return Element("Row", props, list(children), key=key)
 
 
@@ -263,17 +308,6 @@ def ScrollView(
     return Element("ScrollView", props, children, key=key)
 
 
-def View(
-    *children: Element,
-    style: StyleValue = None,
-    key: Optional[str] = None,
-) -> Element:
-    """Generic container view (``UIView`` / ``android.view.View``)."""
-    props: Dict[str, Any] = {}
-    props.update(resolve_style(style))
-    return Element("View", props, list(children), key=key)
-
-
 def SafeAreaView(
     *children: Element,
     style: StyleValue = None,
@@ -323,6 +357,29 @@ def Pressable(
     return Element("Pressable", props, children, key=key)
 
 
+def ErrorBoundary(
+    child: Optional[Element] = None,
+    *,
+    fallback: Optional[Any] = None,
+    key: Optional[str] = None,
+) -> Element:
+    """Catch render errors in *child* and display *fallback* instead.
+
+    *fallback* may be an ``Element`` or a callable that receives the
+    exception and returns an ``Element``::
+
+        pn.ErrorBoundary(
+            MyRiskyComponent(),
+            fallback=lambda err: pn.Text(f"Error: {err}"),
+        )
+    """
+    props: Dict[str, Any] = {}
+    if fallback is not None:
+        props["__fallback__"] = fallback
+    children = [child] if child is not None else []
+    return Element("__ErrorBoundary__", props, children, key=key)
+
+
 def FlatList(
     *,
     data: Optional[List[Any]] = None,