pythonnative 0.18.0__tar.gz → 0.19.0__tar.gz

{pythonnative-0.18.0/src/pythonnative.egg-info → pythonnative-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.18.0
+Version: 0.19.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License
@@ -106,6 +106,7 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 - **Direct native bindings:** Python calls platform APIs directly through Chaquopy and rubicon-objc, with no JavaScript bridge.
 - **Custom-component SDK:** Wrap any platform widget as a first-class element with type-checked props via `pythonnative.sdk` (`Props`, `@native_component`, `element_factory`). Plugins distributed on PyPI auto-register through the `pythonnative.handlers` entry-point group.
 - **CLI scaffolding:** `pn init` creates a ready-to-run project; `pn run android` and `pn run ios` build and launch your app.
+- **Instant desktop preview:** `pn preview` renders your app in a native desktop window via Tkinter with Fast Refresh on every save — iterate on layout, state, and navigation in milliseconds without booting a simulator or device. The reconciler, hooks, layout engine, and navigation are the same code that ships to the phone.
 - **Native-backed navigation:** Declarative `Stack`, `Tab`, and `Drawer` navigators inspired by React Navigation. The root stack drives the platform's native navigation controller (`UINavigationController` on iOS, AndroidX Navigation Component on Android), so transitions, back gestures, and the hardware back button match what users expect.
 - **Fast Refresh hot reload:** `pn run --hot-reload` watches `app/` and patches edits into the running app on save, preserving component state across most changes.
 - **Bundled templates:** Android Gradle and iOS Xcode templates are included, so scaffolding requires no network access.

{pythonnative-0.18.0 → pythonnative-0.19.0}/README.md

@@ -40,6 +40,7 @@ PythonNative is a cross-platform toolkit for building native Android and iOS app
 - **Direct native bindings:** Python calls platform APIs directly through Chaquopy and rubicon-objc, with no JavaScript bridge.
 - **Custom-component SDK:** Wrap any platform widget as a first-class element with type-checked props via `pythonnative.sdk` (`Props`, `@native_component`, `element_factory`). Plugins distributed on PyPI auto-register through the `pythonnative.handlers` entry-point group.
 - **CLI scaffolding:** `pn init` creates a ready-to-run project; `pn run android` and `pn run ios` build and launch your app.
+- **Instant desktop preview:** `pn preview` renders your app in a native desktop window via Tkinter with Fast Refresh on every save — iterate on layout, state, and navigation in milliseconds without booting a simulator or device. The reconciler, hooks, layout engine, and navigation are the same code that ships to the phone.
 - **Native-backed navigation:** Declarative `Stack`, `Tab`, and `Drawer` navigators inspired by React Navigation. The root stack drives the platform's native navigation controller (`UINavigationController` on iOS, AndroidX Navigation Component on Android), so transitions, back gestures, and the hardware back button match what users expect.
 - **Fast Refresh hot reload:** `pn run --hot-reload` watches `app/` and patches edits into the running app on save, preserving component state across most changes.
 - **Bundled templates:** Android Gradle and iOS Xcode templates are included, so scaffolding requires no network access.

{pythonnative-0.18.0 → pythonnative-0.19.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.18.0"
+version = "0.19.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }
@@ -71,6 +71,7 @@ Documentation = "https://docs.pythonnative.com/"
 
 
 
+
 [tool.setuptools.packages.find]
 where = ["src"]
 
@@ -117,6 +118,7 @@ ignore = ["D107", "D105", "D203", "D213"]
 # docstrings would only add boilerplate that repeats the ABC.
 "src/pythonnative/native_views/android.py" = ["D101", "D102"]
 "src/pythonnative/native_views/ios.py" = ["D101", "D102"]
+"src/pythonnative/native_views/desktop.py" = ["D101", "D102"]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"

{pythonnative-0.18.0 → pythonnative-0.19.0}/src/pythonnative/__init__.py

@@ -51,7 +51,7 @@ Example:
     ```
 """
 
-__version__ = "0.18.0"
+__version__ = "0.19.0"
 
 from . import runtime, sdk
 from .alerts import Alert

{pythonnative-0.18.0 → pythonnative-0.19.0}/src/pythonnative/cli/pn.py

@@ -1,9 +1,12 @@
 """`pn` CLI: scaffold, run, and clean PythonNative projects.
 
 The console script `pn` (declared in `pyproject.toml` under
-`[project.scripts]`) dispatches to one of three subcommands:
+`[project.scripts]`) dispatches to one of four subcommands:
 
 - `pn init [name]`: scaffold a new project in the current directory.
+- `pn preview [component]`: render the app in a desktop (Tkinter)
+  window with instant Fast Refresh — the fast inner dev loop, no
+  device or simulator required.
 - `pn run android|ios`: stage code into a native template, build it,
   install it, and stream logs back to the terminal.
 - `pn clean`: remove the local `build/` directory.
@@ -1119,6 +1122,90 @@ def _run_hot_reload(platform: str, project_dir: str, build_dir: str, show_logs:
         print("\n[hot-reload] Stopped.")
 
 
+def _entrypoint_to_module(entry_point: str) -> str:
+    """Convert a config ``entryPoint`` path into an importable module path.
+
+    ``"app/main.py"`` → ``"app.main"``. Returns ``"app.main"`` for
+    empty / unusable input so ``pn preview`` always has a sane default.
+    """
+    normalized = entry_point.strip().replace("\\", "/")
+    if normalized.endswith(".py"):
+        normalized = normalized[:-3]
+    normalized = normalized.strip("/").replace("/", ".")
+    return normalized or "app.main"
+
+
+def preview_project(args: argparse.Namespace) -> None:
+    """Render the project in a desktop preview window (Tkinter).
+
+    Sets ``PN_PLATFORM=desktop`` (so PythonNative selects the Tkinter
+    backend) and hands off to ``pythonnative.preview.run_preview``,
+    which opens a window, mounts the app, and Fast Refreshes on every
+    file save until the window is closed.
+
+    Args:
+        args: Parsed argparse namespace. Recognized attributes:
+
+            - `component` (`str`, optional): Module path like
+              ``"app.main"`` (its ``App`` is used) or a dotted
+              ``module.Component`` path. Defaults to the project's
+              configured ``entryPoint``.
+            - `width` / `height` (`int`): Initial window size in points.
+            - `title` (`str`): Window title.
+            - `no_hot_reload` (`bool`): Disable file watching.
+    """
+    # The desktop backend is selected at *import time* from the
+    # ``PN_PLATFORM`` environment variable (see ``pythonnative.utils`` and
+    # the host selection in ``pythonnative.screen``). Because the ``pn``
+    # console entry point lives inside the ``pythonnative`` package,
+    # importing it already loaded the package under the default,
+    # non-desktop platform before this handler ever runs. Re-exec a fresh
+    # interpreter with the variable set so every module binds to the
+    # Tkinter backend; the re-execed child sees ``PN_PLATFORM=desktop`` and
+    # skips this branch, so there is no exec loop.
+    if os.environ.get("PN_PLATFORM") != "desktop":
+        try:
+            completed = subprocess.run(
+                [sys.executable, "-m", "pythonnative.cli.pn", *sys.argv[1:]],
+                env={**os.environ, "PN_PLATFORM": "desktop"},
+            )
+        except KeyboardInterrupt:
+            sys.exit(130)
+        sys.exit(completed.returncode)
+
+    project_dir = os.getcwd()
+    component: Optional[str] = getattr(args, "component", None)
+    if not component:
+        config = _read_project_config()
+        component = _entrypoint_to_module(config.get("entryPoint", "app/main.py"))
+
+    try:
+        from pythonnative.preview import run_preview
+    except Exception as exc:  # pragma: no cover - environment dependent
+        print(f"Error: could not start the desktop preview: {exc}")
+        print(
+            "The desktop preview needs Tkinter (Python's standard GUI toolkit).\n"
+            "On macOS:        brew install python-tk\n"
+            "On Debian/Ubuntu: sudo apt-get install python3-tk\n"
+            "On Windows:      reinstall Python with the 'tcl/tk' option checked."
+        )
+        sys.exit(1)
+
+    print(f"Starting PythonNative preview for {component} (Ctrl+C or close the window to stop).")
+    try:
+        run_preview(
+            component,
+            project_root=project_dir,
+            width=getattr(args, "width", 390),
+            height=getattr(args, "height", 844),
+            title=getattr(args, "title", "PythonNative Preview"),
+            hot_reload=not getattr(args, "no_hot_reload", False),
+        )
+    except RuntimeError as exc:
+        print(f"Error: {exc}")
+        sys.exit(1)
+
+
 def clean_project(args: argparse.Namespace) -> None:
     """Remove the local `build/` directory.
 
@@ -1152,6 +1239,25 @@ def main() -> None:
     parser_init.add_argument("--force", action="store_true", help="Overwrite existing files if present")
     parser_init.set_defaults(func=init_project)
 
+    # Create a new command 'preview' that calls preview_project
+    parser_preview = subparsers.add_parser("preview")
+    parser_preview.add_argument(
+        "component",
+        nargs="?",
+        help="Module path (e.g. app.main) or dotted component path; defaults to the project entry point",
+    )
+    parser_preview.add_argument("--width", type=int, default=390, help="Initial window width in points (default: 390)")
+    parser_preview.add_argument(
+        "--height", type=int, default=844, help="Initial window height in points (default: 844)"
+    )
+    parser_preview.add_argument("--title", default="PythonNative Preview", help="Preview window title")
+    parser_preview.add_argument(
+        "--no-hot-reload",
+        action="store_true",
+        help="Disable file watching / Fast Refresh",
+    )
+    parser_preview.set_defaults(func=preview_project)
+
     # Create a new command 'run' that calls run_project
     parser_run = subparsers.add_parser("run")
     parser_run.add_argument("platform", choices=["android", "ios"])

{pythonnative-0.18.0 → pythonnative-0.19.0}/src/pythonnative/native_views/__init__.py

@@ -238,18 +238,31 @@ _registry: Optional[NativeViewRegistry] = None
 
 
 def _active_platform_name() -> str:
-    """Return ``"android"`` or ``"ios"`` for the active runtime."""
-    from ..utils import IS_ANDROID
+    """Return ``"android"``, ``"desktop"``, or ``"ios"`` for the active runtime."""
+    from ..utils import IS_ANDROID, IS_DESKTOP
 
-    return "android" if IS_ANDROID else "ios"
+    if IS_ANDROID:
+        return "android"
+    if IS_DESKTOP:
+        return "desktop"
+    return "ios"
 
 
 def _register_builtin_handlers(registry: NativeViewRegistry) -> None:
-    """Register every built-in handler for the active platform."""
-    from ..utils import IS_ANDROID
+    """Register every built-in handler for the active platform.
+
+    The desktop (Tkinter) backend is selected when ``pn preview`` sets
+    ``PN_PLATFORM=desktop``; otherwise this picks Android (on device) or
+    iOS (the default off-device path, exercised by the iOS templates and
+    by tests that install the ``[ios]`` extra). Off-device unit tests
+    typically inject a mock registry via ``set_registry`` instead.
+    """
+    from ..utils import IS_ANDROID, IS_DESKTOP
 
     if IS_ANDROID:
         from .android import register_handlers
+    elif IS_DESKTOP:
+        from .desktop import register_handlers
     else:
         from .ios import register_handlers
     register_handlers(registry)