pythonnative 0.41.0__tar.gz → 0.43.0__tar.gz

{pythonnative-0.41.0/src/pythonnative.egg-info → pythonnative-0.43.0}/PKG-INFO

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

{pythonnative-0.41.0 → pythonnative-0.43.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.41.0"
+version = "0.43.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }
@@ -51,6 +51,7 @@ dev = [
   # platform tags (project/deps.py), and the test suite exercises that
   # path. `uv sync` does not seed pip the way `uv venv --seed` did.
   "pip>=24.0",
+  "websockets>=15",
 ]
 docs = [
   "mkdocs>=1.5",

{pythonnative-0.41.0 → pythonnative-0.43.0}/src/pythonnative/__init__.py

@@ -64,7 +64,7 @@ Example:
     ```
 """
 
-__version__ = "0.41.0"
+__version__ = "0.43.0"
 
 from . import appearance, diagnostics, gestures, runtime, sdk
 from .alerts import Alert

{pythonnative-0.41.0 → pythonnative-0.43.0}/src/pythonnative/animated.py

@@ -1339,8 +1339,14 @@ def _resolve_style_with_values(style: StyleProp) -> Tuple[Dict[str, Any], Dict[s
     flat = resolve_style(style)
     bindings: Dict[str, AnimatedNode] = {}
     plain: Dict[str, Any] = {}
+    transforms: List[Dict[str, Any]] = []
     for k, v in flat.items():
-        if isinstance(v, AnimatedNode):
+        if k in _ANIMATED_TRANSFORM_KEYS:
+            if isinstance(v, AnimatedNode):
+                bindings[k] = v
+                v = v.value
+            transforms.append({k: v})
+        elif isinstance(v, AnimatedNode):
             bindings[k] = v
             plain[k] = v.value
         elif k == "transform" and v is not None:
@@ -1361,6 +1367,11 @@ def _resolve_style_with_values(style: StyleProp) -> Tuple[Dict[str, Any], Dict[s
             plain[k] = plain_entries
         else:
             plain[k] = v
+    if transforms:
+        # Native styles use the same transform shape for the initial frame
+        # and later renders, even when Animated accepts a top-level binding.
+        existing = plain.get("transform") or []
+        plain["transform"] = (existing if isinstance(existing, list) else [existing]) + transforms
     return plain, bindings
 
 

{pythonnative-0.41.0 → pythonnative-0.43.0}/src/pythonnative/bridge/__init__.py

@@ -217,8 +217,7 @@ def native_callback(kind: str, tag: int, name: str, payload: str) -> Optional[st
             from ..native_views import get_registry
 
             backend = get_registry()
-            if backend.on_layout is not None:
-                backend.on_layout(codec.loads(payload))
+            backend.accept_layout(codec.loads(payload))
             return None
         if kind == "event":
             return _on_event(int(tag), name, payload)

{pythonnative-0.41.0 → pythonnative-0.43.0}/src/pythonnative/bridge/commits.py

@@ -7,11 +7,13 @@ poisons that surface until the host explicitly resets and remounts it.
 
 from __future__ import annotations
 
-import copy
 import math
+from collections.abc import Iterator, MutableMapping
 from dataclasses import dataclass, field
 from typing import Any
 
+from ..profiling import count, profiled
+
 PROTOCOL_VERSION = 2
 
 
@@ -29,6 +31,59 @@ class ViewState:
     children: list[int] = field(default_factory=list)
 
 
+class ViewOverlay(MutableMapping[int, ViewState]):
+    """Copy only records written by a candidate commit.
+
+    Publishing consumes the candidate and updates its owned base in place. A
+    rejected candidate is simply discarded. There is no chain of old revisions.
+    """
+
+    def __init__(self, base: MutableMapping[int, ViewState]) -> None:
+        self.base = base
+        self.changed: dict[int, ViewState] = {}
+        self.deleted: set[int] = set()
+
+    def __getitem__(self, tag: int) -> ViewState:
+        if tag in self.deleted:
+            raise KeyError(tag)
+        return self.changed[tag] if tag in self.changed else self.base[tag]
+
+    def __setitem__(self, tag: int, value: ViewState) -> None:
+        self.deleted.discard(tag)
+        self.changed[tag] = value
+
+    def __delitem__(self, tag: int) -> None:
+        self[tag]
+        self.changed.pop(tag, None)
+        self.deleted.add(tag)
+
+    def __iter__(self) -> Iterator[int]:
+        yield from (tag for tag in self.base if tag not in self.deleted and tag not in self.changed)
+        yield from self.changed
+
+    def __len__(self) -> int:
+        return (
+            len(self.base)
+            - sum(tag in self.base for tag in self.deleted)
+            + sum(tag not in self.base for tag in self.changed)
+        )
+
+    def edit(self, tag: int) -> ViewState:
+        """Return a writable copy of this record, copying it at most once."""
+        if tag not in self.changed:
+            view = self[tag]
+            self.changed[tag] = ViewState(view.type_name, dict(view.props), view.parent, list(view.children))
+            count("commit.records_copied")
+        return self.changed[tag]
+
+    def publish(self) -> MutableMapping[int, ViewState]:
+        """Apply accepted records to the owned base without a revision chain."""
+        for tag in self.deleted:
+            del self.base[tag]
+        self.base.update(self.changed)
+        return self.base
+
+
 @dataclass
 class CommitState:
     """Committed revision and structural state for one native surface."""
@@ -36,8 +91,9 @@ class CommitState:
     application: str = ""
     surface: int = 0
     revision: int = 0
-    views: dict[int, ViewState] = field(default_factory=dict)
+    views: MutableMapping[int, ViewState] = field(default_factory=dict)
 
+    @profiled("validation")
     def prepare(self, envelope: Any) -> CommitState:
         """Validate without mutating this state and return the candidate state."""
         if not isinstance(envelope, dict) or envelope.get("version") != PROTOCOL_VERSION:
@@ -52,7 +108,9 @@ class CommitState:
         ops = envelope.get("ops")
         if not isinstance(ops, list):
             raise CommitError("Commit ops must be a list")
-        result = CommitState(application, surface, revision, copy.deepcopy(self.views))
+        if isinstance(self.views, ViewOverlay):
+            raise CommitError("Publish the previous candidate before preparing another commit")
+        result = CommitState(application, surface, revision, ViewOverlay(self.views))
         for index, op in enumerate(ops):
             try:
                 result._validate_op(op)
@@ -60,6 +118,16 @@ class CommitState:
                 raise CommitError(f"Invalid op {index}: {exc}") from exc
         return result
 
+    def publish(self) -> CommitState:
+        """Accept a successfully mounted candidate; the prior state is consumed."""
+        if isinstance(self.views, ViewOverlay):
+            self.views = self.views.publish()
+        return self
+
+    def _edit(self, tag: int) -> ViewState:
+        assert isinstance(self.views, ViewOverlay)
+        return self.views.edit(tag)
+
     def _validate_op(self, op: Any) -> None:
         if not isinstance(op, list) or len(op) < 2:
             raise ValueError("Expected an operation array")
@@ -70,12 +138,14 @@ class CommitState:
         if code == "c":
             if tag in self.views or not isinstance(op[2], str) or not op[2] or not isinstance(op[3], dict):
                 raise ValueError("Invalid or duplicate create")
+            self._validate_props(op[2], op[3], False)
             self.views[tag] = ViewState(op[2], dict(op[3]))
             return
-        view = self.views[tag]
+        view = self.views[tag] if code == "f" else self._edit(tag)
         if code == "u":
             if not isinstance(op[2], dict):
                 raise ValueError("Update requires a property mapping")
+            self._validate_props(view.type_name, op[2], True)
             for name, value in op[2].items():
                 if value is None:
                     view.props.pop(name, None)
@@ -85,14 +155,14 @@ class CommitState:
             child_tag, index = op[2:]
             if type(child_tag) is not int or type(index) is not int or index < 0:
                 raise ValueError("Invalid child or insertion index")
-            child = self.views[child_tag]
+            child = self._edit(child_tag)
             ancestor: int | None = tag
             while ancestor is not None:
                 if ancestor == child_tag:
                     raise ValueError("Insertion creates a cycle")
                 ancestor = self.views[ancestor].parent
             if child.parent is not None:
-                self.views[child.parent].children.remove(child_tag)
+                self._edit(child.parent).children.remove(child_tag)
             if index > len(view.children):
                 raise ValueError("Insertion index exceeds child count")
             view.children.insert(index, child_tag)
@@ -101,7 +171,7 @@ class CommitState:
             if view.children:
                 raise ValueError("Destroy children before their parent")
             if view.parent is not None:
-                self.views[view.parent].children.remove(tag)
+                self._edit(view.parent).children.remove(tag)
             del self.views[tag]
         elif code == "f":
             if any(type(n) not in (float, int) or not math.isfinite(n) for n in op[2:]):
@@ -109,6 +179,14 @@ class CommitState:
             if op[4] < 0 or op[5] < 0:
                 raise ValueError("Frame sizes must be nonnegative")
 
+    @staticmethod
+    def _validate_props(name: str, props: dict[str, Any], partial: bool) -> None:
+        from ..sdk.schema import COMPONENTS
+
+        schema = COMPONENTS.get(name)
+        if schema is not None:
+            schema.validate(props, partial=partial)
+
     def acknowledgement(self) -> dict[str, Any]:
         """Identify the exact revision native successfully mounted."""
         return {"ok": True, "application": self.application, "surface": self.surface, "revision": self.revision}

{pythonnative-0.41.0 → pythonnative-0.43.0}/src/pythonnative/bridge/fake.py

@@ -98,7 +98,7 @@ class FakeTransport:
         self.transactions.append(ops)
         for op in ops:
             self._apply_one(op)
-        self.commit_state = candidate
+        self.commit_state = candidate.publish()
         return codec.dumps(candidate.acknowledgement())
 
     def _apply_one(self, op: List[Any]) -> None:

{pythonnative-0.41.0 → pythonnative-0.43.0}/src/pythonnative/cli/pn.py

@@ -25,7 +25,7 @@ The console script `pn` (declared in `pyproject.toml`) dispatches to:
 - `pn build android|ios`: produce standalone artifacts (signed APK/AAB,
   or an iOS archive/IPA, optionally uploaded to App Store Connect).
 - `pn app-id android|ios`: print the resolved application/bundle id
-  (handy for scripts and CI).
+  (handy for scripts and CI), as plain text or as JSON with `--json`.
 - `pn clean`: remove the local `build/` directory.
 
 The heavy lifting lives in the ``pythonnative.project`` and
@@ -147,6 +147,37 @@ def _sanitize_name(name: str) -> str:
 
 
 def _app_id_from_name(name: str) -> str:
+    """Derive the default reverse-DNS app id from a project name.
+
+    The result is an identifier rather than a name, and it fills
+    ``app.id``, the default for both the Android application id and the
+    iOS bundle id. It therefore has to satisfy the stricter of the two
+    grammars, ``config._APP_ID_SEGMENT``, which admits no hyphen. An
+    explicit ``[ios].bundle_id`` may contain one, because
+    ``config._validate_app_id`` is called with ``allow_hyphen=True`` for
+    that field alone.
+
+    Deleting hyphens is lossy, so the derivation is not injective:
+    ``my-app`` and ``myapp`` both give ``com.example.myapp``. Mapping
+    ``-`` to ``_`` instead would not fix that, only move it, since
+    ``_NAME_RE`` permits both characters and ``my-app`` would then
+    collide with ``my_app``. Injectivity would need an escaping scheme;
+    deletion is the deliberate choice here.
+
+    The ``app`` prefix covers the name taken from the current directory
+    when ``pn init`` is given none. A typed name cannot reach it, because
+    ``_NAME_RE`` already guarantees a leading letter.
+
+    The result always satisfies ``_APP_ID_SEGMENT`` but is not guaranteed
+    to pass ``config._validate_app_id``, which also rejects reserved
+    words: ``class`` is a legal project name and passes through here.
+
+    Args:
+        name: A project name, either typed or taken from the directory.
+
+    Returns:
+        A reverse-DNS id under ``com.example``.
+    """
     slug = re.sub(r"[^a-z0-9_]", "", name.lower())
     if not slug or not slug[0].isalpha():
         slug = "app" + slug
@@ -312,11 +343,27 @@ def doctor_command(args: argparse.Namespace) -> None:
 def app_id_command(args: argparse.Namespace) -> None:
     """Print the resolved application id (Android) or bundle id (iOS).
 
+    With ``--json``, stdout carries one object,
+    ``{"platform": "...", "app_id": "..."}``, and nothing else; the config
+    error goes to stderr instead so stdout stays parseable. Keys may be
+    added to that object later, but none will be removed or renamed, so
+    a caller reading ``app_id`` keeps working.
+
+    A missing or invalid config still exits 1, with or without the flag.
+    That differs from ``pn devices --json``, which exits 0 on an empty
+    result, because "no devices" is a valid answer to a query whereas
+    an unreadable config means there is no id to report at all.
+
     Args:
-        args: Parsed namespace with ``platform``.
+        args: Parsed namespace with ``platform`` and optional ``json``.
     """
-    config = _load_config_or_exit()
-    print(config.application_id if args.platform == "android" else config.bundle_id)
+    as_json: bool = getattr(args, "json", False)
+    config = _load_config_or_exit(stream=sys.stderr if as_json else None)
+    app_id = config.application_id if args.platform == "android" else config.bundle_id
+    if as_json:
+        print(json.dumps({"platform": args.platform, "app_id": app_id}, indent=2))
+        return
+    print(app_id)
 
 
 # ======================================================================
@@ -950,11 +997,22 @@ def clean_project(args: argparse.Namespace) -> None:
 # ======================================================================
 
 
-def _load_config_or_exit(project_dir: Optional[Path] = None) -> AppConfig:
+def _load_config_or_exit(project_dir: Optional[Path] = None, *, stream: Optional[TextIO] = None) -> AppConfig:
+    """Load the project config or exit 1, reporting the error on ``stream``.
+
+    Args:
+        project_dir: Project root; defaults to the current directory.
+        stream: Where to report a failure. Defaults to stdout, which is
+            what every caller wants except a machine-readable mode, where
+            an error on stdout would corrupt the document.
+
+    Returns:
+        The loaded config.
+    """
     try:
         return AppConfig.load(project_dir or Path.cwd())
     except ConfigError as exc:
-        print(f"Error: {exc}")
+        print(f"Error: {exc}", file=stream or sys.stdout)
         sys.exit(1)
 
 
@@ -1169,7 +1227,7 @@ def _build_parser() -> argparse.ArgumentParser:
     parser_devices.set_defaults(func=devices_command)
 
     parser_run = subparsers.add_parser("run", help="Build, install, and launch on a device/simulator")
-    parser_run.add_argument("platform", choices=["android", "ios"])
+    parser_run.add_argument("platform", choices=["android", "ios"], help="Target platform")
     parser_run.add_argument(
         "--device",
         "-d",
@@ -1196,7 +1254,7 @@ def _build_parser() -> argparse.ArgumentParser:
     parser_run.set_defaults(func=run_project)
 
     parser_logs = subparsers.add_parser("logs", help="Stream logs from the running app")
-    parser_logs.add_argument("platform", choices=["android", "ios"])
+    parser_logs.add_argument("platform", choices=["android", "ios"], help="Target platform")
     parser_logs.add_argument(
         "--device",
         "-d",
@@ -1206,7 +1264,7 @@ def _build_parser() -> argparse.ArgumentParser:
     parser_logs.set_defaults(func=logs_command)
 
     parser_build = subparsers.add_parser("build", help="Build distributable artifacts")
-    parser_build.add_argument("platform", choices=["android", "ios"])
+    parser_build.add_argument("platform", choices=["android", "ios"], help="Target platform")
     parser_build.add_argument("--debug", action="store_true", help="Build the debug variant instead of release")
     parser_build.add_argument(
         "--upload",
@@ -1216,7 +1274,10 @@ def _build_parser() -> argparse.ArgumentParser:
     parser_build.set_defaults(func=build_project)
 
     parser_app_id = subparsers.add_parser("app-id", help="Print the resolved application/bundle id")
-    parser_app_id.add_argument("platform", choices=["android", "ios"])
+    parser_app_id.add_argument("platform", choices=["android", "ios"], help="Target platform")
+    parser_app_id.add_argument(
+        "--json", action="store_true", help="Print a JSON object to stdout for scripting (errors go to stderr)"
+    )
     parser_app_id.set_defaults(func=app_id_command)
 
     parser_clean = subparsers.add_parser("clean", help="Remove the local build/ directory")

{pythonnative-0.41.0 → pythonnative-0.43.0}/src/pythonnative/component.py

@@ -46,7 +46,7 @@ from __future__ import annotations
 
 import functools
 import inspect
-from typing import Any, Awaitable, Callable, Dict, Generic, List, Optional, ParamSpec, Tuple, Union, overload
+from typing import Any, Awaitable, Callable, Dict, Generic, Mapping, Optional, ParamSpec, Union, overload
 
 from .element import Element, Node
 
@@ -82,7 +82,7 @@ class Component(Generic[P]):
         "memoized",
         "props_equal",
         "accepts_children",
-        "_positional",
+        "_signature",
         "_declares_key",
         "_is_async",
         "refresh_signature",
@@ -94,13 +94,10 @@ class Component(Generic[P]):
         if isinstance(fn, Component):
             raise TypeError(f"{fn!r} is already a component; remove the duplicate @component")
         sig = inspect.signature(fn)
-        positional: List[str] = []
         accepts_children = False
         declares_key = False
         for name, param in sig.parameters.items():
-            if param.kind in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD):
-                positional.append(name)
-            elif param.kind is inspect.Parameter.VAR_POSITIONAL:
+            if param.kind is inspect.Parameter.VAR_POSITIONAL:
                 accepts_children = True
             if name == "key":
                 declares_key = True
@@ -110,9 +107,9 @@ class Component(Generic[P]):
         self.fn = fn
         self.display_name = display_name or getattr(fn, "__name__", "Component")
         self.memoized = False
-        self.props_equal: Optional[Callable[[Dict[str, Any], Dict[str, Any]], bool]] = None
+        self.props_equal: Optional[Callable[[Mapping[str, Any], Mapping[str, Any]], bool]] = None
         self.accepts_children = accepts_children
-        self._positional: Tuple[str, ...] = tuple(positional)
+        self._signature = sig
         self._declares_key = declares_key
         self._is_async = inspect.iscoroutinefunction(fn)
         self.__wrapped__ = fn
@@ -126,21 +123,16 @@ class Component(Generic[P]):
         """Describe a render of this component with the given props."""
         props: Dict[str, Any] = dict(kwargs)
         key = props.pop("key", None) if not self._declares_key else props.get("key")
-        children: List[Any] = []
-        if args:
-            if self.accepts_children:
-                children = list(args)
+        bound = self._signature.bind(*args, **props)
+        bound.apply_defaults()
+        children = ()
+        props = {}
+        for name, value in bound.arguments.items():
+            kind = self._signature.parameters[name].kind
+            if kind is inspect.Parameter.VAR_POSITIONAL:
+                children = value
             else:
-                names = self._positional
-                if len(args) > len(names):
-                    raise TypeError(
-                        f"{self.display_name}() takes {len(names)} positional argument(s) but "
-                        f"{len(args)} were given. Declare *children to accept child elements."
-                    )
-                for name, value in zip(names, args):
-                    if name in props:
-                        raise TypeError(f"{self.display_name}() got multiple values for argument {name!r}")
-                    props[name] = value
+                props[name] = value
         return Element(self, props, children, key=key if isinstance(key, str) or key is None else str(key))
 
     # ------------------------------------------------------------------
@@ -155,9 +147,12 @@ class Component(Generic[P]):
         (an element, a list, ``None``, or a coroutine for ``async def``
         bodies).
         """
-        if self.accepts_children:
-            return self.fn(*element.children, **element.props)
-        return self.fn(**element.props)  # type: ignore[call-arg]
+        arguments = dict(element.props)
+        for name, param in self._signature.parameters.items():
+            if param.kind is inspect.Parameter.VAR_POSITIONAL:
+                arguments[name] = element.children
+        bound = inspect.BoundArguments(self._signature, arguments)
+        return self.fn(*bound.args, **bound.kwargs)
 
     @property
     def is_async(self) -> bool:
@@ -204,20 +199,20 @@ def component(fn: RenderFn[P]) -> Component[P]:
 
 @overload
 def memo(
-    target: Component[P], *, equal: Optional[Callable[[Dict[str, Any], Dict[str, Any]], bool]] = None
+    target: Component[P], *, equal: Optional[Callable[[Mapping[str, Any], Mapping[str, Any]], bool]] = None
 ) -> Component[P]: ...
 
 
 @overload
 def memo(
-    target: None = None, *, equal: Optional[Callable[[Dict[str, Any], Dict[str, Any]], bool]] = None
+    target: None = None, *, equal: Optional[Callable[[Mapping[str, Any], Mapping[str, Any]], bool]] = None
 ) -> Callable[[Component[P]], Component[P]]: ...
 
 
 def memo(
     target: Optional[Component[P]] = None,
     *,
-    equal: Optional[Callable[[Dict[str, Any], Dict[str, Any]], bool]] = None,
+    equal: Optional[Callable[[Mapping[str, Any], Mapping[str, Any]], bool]] = None,
 ) -> Any:
     """Skip a component's render when its props haven't changed.
 

{pythonnative-0.41.0 → pythonnative-0.43.0}/src/pythonnative/components/__init__.py

@@ -56,11 +56,8 @@ from .lists import (  # noqa: F401
     FlatList,
     ListController,
     SectionList,
-    _dispatch_scroll_command,
-    _native_lists_supported,
     _NativeList,
     _RowSpec,
-    _VirtualizedList,
 )
 from .media import Image, ImageBackground, WebView
 from .overlays import Modal, Portal