pythonnative 0.30.0__tar.gz → 0.32.0__tar.gz

{pythonnative-0.30.0/src/pythonnative.egg-info → pythonnative-0.32.0}/PKG-INFO

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

{pythonnative-0.30.0 → pythonnative-0.32.0}/pyproject.toml

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

{pythonnative-0.30.0 → pythonnative-0.32.0}/src/pythonnative/__init__.py

@@ -60,7 +60,7 @@ Example:
     ```
 """
 
-__version__ = "0.30.0"
+__version__ = "0.32.0"
 
 from . import appearance, diagnostics, gestures, images, runtime, sdk
 from .alerts import Alert

{pythonnative-0.30.0 → pythonnative-0.32.0}/src/pythonnative/cli/pn.py

@@ -9,7 +9,7 @@ The console script `pn` (declared in `pyproject.toml`) dispatches to:
 - `pn preview [component]`: render the app in a desktop (Tkinter) window
   with Fast Refresh, the fast inner dev loop, no device required.
 - `pn devices [platform]`: list connected devices, emulators, and
-  simulators.
+  simulators, as a table or as JSON with `--json`.
 - `pn run android|ios [--device D]`: stage + build + install + launch on
   a device, emulator, or simulator, with optional on-device hot reload.
 - `pn logs android|ios`: stream logs from the running app without
@@ -38,7 +38,7 @@ import sys
 import time
 from importlib.metadata import version as pkg_version
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, TextIO
 
 from ..project import builder as builder_mod
 from ..project import devices as devices_mod
@@ -98,6 +98,35 @@ def App():
 _GITIGNORE = "# PythonNative\n__pycache__/\n*.pyc\n.venv/\nbuild/\n.DS_Store\n"
 
 
+_NAME_RE = re.compile(r"^[a-z][a-z0-9_-]*$")
+"""Legal ``pn init`` project names, in the spirit of ``flutter create`` / ``cargo new``."""
+
+_FALLBACK_NAME = "my_app"
+
+
+def _sanitize_name(name: str) -> str:
+    """Return a legal project name derived from ``name``.
+
+    Lowercases, collapses each run of illegal characters to one
+    underscore, trims leading and trailing ``_`` and ``-``, and prefixes
+    a name that doesn't start with a letter. The result always matches
+    ``_NAME_RE``, falling back to ``_FALLBACK_NAME`` when nothing usable
+    survives.
+
+    Args:
+        name: The rejected name, which may be empty.
+
+    Returns:
+        A name suitable for suggesting back to the user.
+    """
+    slug = re.sub(r"[^a-z0-9_-]+", "_", name.lower()).strip("_-")
+    if not slug:
+        return _FALLBACK_NAME
+    if not slug[0].isascii() or not slug[0].isalpha():
+        slug = f"app_{slug}"
+    return slug
+
+
 def _app_id_from_name(name: str) -> str:
     slug = re.sub(r"[^a-z0-9_]", "", name.lower())
     if not slug or not slug[0].isalpha():
@@ -113,9 +142,17 @@ def init_project(args: argparse.Namespace) -> None:
     it. Either way it writes ``app/main.py``, ``pythonnative.toml``, and
     ``.gitignore``.
 
-    The name has to be a single directory name, so the project always lands
-    inside the current directory. Anything that reads as a path, such as
-    ``a/b``, ``..``, or ``/tmp/app``, is refused, and so is a name that
+    A name you pass has to match ``^[a-z][a-z0-9_-]*$``: lowercase letters,
+    digits, ``-``, and ``_``, starting with a letter. Anything else is
+    refused with a legal suggestion. That keeps the directory name and the
+    ``name`` field in the generated config identical, in the same spirit as
+    ``flutter create`` and ``cargo new``. The name taken from the current
+    directory when you pass none is used as-is, so an existing directory
+    with any name still works.
+
+    The name also has to be a single directory name, so the project always
+    lands inside the current directory. Anything that reads as a path, such
+    as ``a/b``, ``..``, or ``/tmp/app``, is refused, and so is a name that
     resolves somewhere else, such as a symlink to another directory.
 
     It won't scaffold into a target directory that already holds files, and it
@@ -137,6 +174,19 @@ def init_project(args: argparse.Namespace) -> None:
         print(f"Refusing to treat a path as a project name: {name!r}. Use a single directory name like my_app.")
         sys.exit(1)
 
+    # Charset check, still lexical, so it stays ahead of ``Path.cwd()`` below.
+    # ``is not None`` rather than truthiness: "" is invalid under the pattern,
+    # and falling through to the no-name path would silently scaffold here.
+    # ``fullmatch``, not ``match``: ``$`` also matches before a trailing
+    # newline, so ``match`` would accept "app\n" and create a directory
+    # whose name contains one.
+    if name is not None and not _NAME_RE.fullmatch(name):
+        print(
+            f"Invalid project name: {name!r}. Use lowercase letters, digits, '-', and '_', "
+            f"starting with a letter. Try: {_sanitize_name(name)}"
+        )
+        sys.exit(1)
+
     cwd = Path.cwd()
     target = cwd / name if name else cwd
     project_name: str = name or cwd.name
@@ -298,18 +348,46 @@ def _preview_entry(project_dir: Path) -> str:
 # ======================================================================
 
 
+def _print_no_devices_hints(stream: TextIO) -> None:
+    """Print the "no devices" guidance to ``stream``.
+
+    Shared by both output modes so the wording can't drift between the
+    table (which sends it to stdout) and ``--json`` (stderr).
+
+    Args:
+        stream: Where to write, ``sys.stdout`` or ``sys.stderr``.
+    """
+    print("No devices found.", file=stream)
+    print("Android: start an emulator or connect a device with USB debugging enabled.", file=stream)
+    print("iOS: open Xcode once to install Simulators, or plug in a device.", file=stream)
+
+
 def devices_command(args: argparse.Namespace) -> None:
     """List connected devices, emulators, and simulators.
 
+    Prints an aligned table and exits 1 when nothing is connected.
+
+    With ``--json``, stdout carries a JSON array and nothing else, one
+    object per device (see ``Device.to_dict``), so it stays parseable.
+    The "no devices" hints go to stderr instead, an empty result prints
+    ``[]``, and the exit status is 0 either way, since "no devices" is a
+    valid answer for a script rather than a failure.
+
     Args:
-        args: Parsed namespace with optional ``platform``.
+        args: Parsed namespace with optional ``platform`` and ``json``.
     """
     platform: Optional[str] = getattr(args, "platform", None)
+    as_json: bool = getattr(args, "json", False)
     devices = devices_mod.list_devices(platform)
+
+    if as_json:
+        if not devices:
+            _print_no_devices_hints(sys.stderr)
+        print(json.dumps([device.to_dict() for device in devices], indent=2))
+        return
+
     if not devices:
-        print("No devices found.")
-        print("Android: start an emulator or connect a device with USB debugging enabled.")
-        print("iOS: open Xcode once to install Simulators, or plug in a device.")
+        _print_no_devices_hints(sys.stdout)
         sys.exit(1)
     print(f"  {'IDENTIFIER':<40} {'KIND':<10} {'STATE':<10} NAME")
     for device in devices:
@@ -919,7 +997,11 @@ def _build_parser() -> argparse.ArgumentParser:
     subparsers = parser.add_subparsers()
 
     parser_init = subparsers.add_parser("init", help="Scaffold a new project")
-    parser_init.add_argument("name", nargs="?", help="Project name; creates ./<name>/ (default: current directory)")
+    parser_init.add_argument(
+        "name",
+        nargs="?",
+        help="Project name, matching ^[a-z][a-z0-9_-]*$; creates ./<name>/ (default: current directory)",
+    )
     parser_init.add_argument("--force", action="store_true", help="Overwrite existing files or a non-empty directory")
     parser_init.set_defaults(func=init_project)
 
@@ -943,6 +1025,9 @@ def _build_parser() -> argparse.ArgumentParser:
 
     parser_devices = subparsers.add_parser("devices", help="List devices, emulators, and simulators")
     parser_devices.add_argument("platform", nargs="?", choices=["android", "ios"], help="Restrict to a platform")
+    parser_devices.add_argument(
+        "--json", action="store_true", help="Print a JSON array to stdout for scripting (hints go to stderr)"
+    )
     parser_devices.set_defaults(func=devices_command)
 
     parser_run = subparsers.add_parser("run", help="Build, install, and launch on a device/simulator")

{pythonnative-0.30.0 → pythonnative-0.32.0}/src/pythonnative/platform_metrics.py

@@ -226,12 +226,15 @@ def reset_keyboard_height() -> None:
 # that natural height. Forcing our own height threw off the pill
 # geometry, so the Android handler defers entirely to the system.
 
-#: UIKit HIG tab-bar content height in points. The total bar reaches
-#: ``IOS_TAB_BAR_BASE_HEIGHT_PT + safe_area_insets.bottom`` so the
-#: pill background can extend over the home indicator. Apple's HIG
-#: places the tab bar flush with the screen edge and lets UIKit
-#: render its own internal padding for the home indicator.
 IOS_TAB_BAR_BASE_HEIGHT_PT: float = 49.0
+"""UIKit HIG tab-bar content height in points.
+
+The total bar reaches ``IOS_TAB_BAR_BASE_HEIGHT_PT +
+safe_area_insets.bottom`` so the pill background can extend over the
+home indicator. Apple's HIG places the tab bar flush with the screen
+edge and lets UIKit render its own internal padding for the home
+indicator.
+"""
 
 
 def ios_tab_bar_height() -> float:

{pythonnative-0.30.0 → pythonnative-0.32.0}/src/pythonnative/project/config.py

@@ -586,9 +586,52 @@ def entrypoint_to_module(entry_point: str) -> str:
     return normalized or "app.main"
 
 
+# TOML v1.0.0 basic strings must escape the quotation mark, the backslash,
+# and every control character except tab: U+0000-U+0008, U+000A-U+001F, and
+# U+007F. Tab is legal raw, and U+000B has no compact escape, so anything
+# without one falls through to \uXXXX.
+_TOML_COMPACT_ESCAPES = {
+    "\\": "\\\\",
+    '"': '\\"',
+    "\b": "\\b",
+    "\f": "\\f",
+    "\n": "\\n",
+    "\r": "\\r",
+}
+
+
+def _toml_escape(value: str) -> str:
+    """Escape ``value`` for use inside a TOML basic string.
+
+    Applied at the render boundary rather than relying on the caller,
+    since this module is public API and reachable without ``pn init``'s
+    name validation in front of it.
+
+    Args:
+        value: The raw string to embed between double quotes.
+
+    Returns:
+        The escaped text, without the surrounding quotes.
+    """
+    out = []
+    for char in value:
+        escaped = _TOML_COMPACT_ESCAPES.get(char)
+        if escaped is not None:
+            out.append(escaped)
+        elif char != "\t" and (char < "\x20" or char == "\x7f"):
+            out.append(f"\\u{ord(char):04X}")
+        else:
+            out.append(char)
+    return "".join(out)
+
+
 def render_default_toml(*, name: str, app_id: str, python_version: str = "3.11") -> str:
     """Render a starter ``pythonnative.toml`` for ``pn init``.
 
+    Every interpolated value is escaped for a TOML basic string, so a
+    name containing a quote, a backslash, or a control character still
+    produces a parseable file.
+
     Args:
         name: Project name.
         app_id: Reverse-DNS app identifier.
@@ -599,6 +642,10 @@ def render_default_toml(*, name: str, app_id: str, python_version: str = "3.11")
         for the optional tables.
     """
     display = name.replace("_", " ").replace("-", " ").strip().title() or name
+    name = _toml_escape(name)
+    display = _toml_escape(display)
+    app_id = _toml_escape(app_id)
+    python_version = _toml_escape(python_version)
     return f"""# PythonNative project configuration.
 # Docs: https://pythonnative.com/guides/configuration/
 

{pythonnative-0.30.0 → pythonnative-0.32.0}/src/pythonnative/project/devices.py

@@ -18,7 +18,7 @@ import json
 import re
 import subprocess
 import tempfile
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -64,6 +64,19 @@ class Device:
             return self.state in ("booted", "shutdown")
         return self.state in ("booted", "connected")
 
+    def to_dict(self) -> Dict[str, Any]:
+        """Return a JSON-serializable view of this target.
+
+        Derived from the dataclass fields so a field added later is
+        carried into the payload automatically, plus the computed
+        ``is_ready`` that consumers would otherwise have to re-derive
+        from ``kind`` and ``state``.
+
+        Returns:
+            The declared fields in declaration order, then ``is_ready``.
+        """
+        return {**asdict(self), "is_ready": self.is_ready}
+
     def format(self) -> str:
         """Return one aligned listing row for the CLI."""
         os_part = f" ({self.os_version})" if self.os_version else ""

{pythonnative-0.30.0 → pythonnative-0.32.0/src/pythonnative.egg-info}/PKG-INFO

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