pythonnative 0.39.0__tar.gz → 0.41.0__tar.gz

pythonnative-0.41.0/.github/workflows/release.yml

@@ -0,0 +1,115 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Existing release tag to recover (leave empty for a new release)
+        type: string
+        required: false
+
+# Serialize the entire release, including manual recoveries and uploads.
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+
+jobs:
+  release:
+    if: github.repository == 'pythonnative/pythonnative' && github.ref == 'refs/heads/main'
+    name: Select release
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+    outputs:
+      # PSR writes its own `tag` output even when released=false. Forward
+      # only outputs we explicitly set after selecting a source commit.
+      tag: ${{ steps.select.outputs.release_tag }}
+      commit: ${{ steps.select.outputs.release_commit }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: astral-sh/setup-uv@v10.0.1
+        with:
+          python-version: '3.13'
+      - name: Create a version or select an existing release
+        id: select
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          RECOVERY_TAG: ${{ inputs.tag }}
+        run: |
+          if [ -n "$RECOVERY_TAG" ]; then
+            # Only published release tags from main can be recovered.
+            [[ "$RECOVERY_TAG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]
+            commit=$(git rev-parse --verify "refs/tags/$RECOVERY_TAG^{commit}")
+            git merge-base --is-ancestor "$commit" origin/main
+            gh release view "$RECOVERY_TAG" --json isDraft --jq '.isDraft' | grep -qx false
+            tag="$RECOVERY_TAG"
+          else
+            git config user.name "github-actions"
+            git config user.email "actions@github.com"
+            # GitPython 3.1.60 removed Actor.name_email_regex, which PSR
+            # 9.21.2 still uses. Keep this constraint until PSR is upgraded.
+            uv tool install "python-semantic-release==9.21.2" --with "gitpython<3.1.60"
+            tags_before=$(git tag | wc -l)
+            semantic-release -v version
+            tags_after=$(git tag | wc -l)
+            if [ "$tags_after" -eq "$tags_before" ]; then
+              echo "No new release. To resume an upload, run this workflow with its existing tag."
+              exit 0
+            fi
+            tag=$(git describe --tags --exact-match HEAD)
+            commit=$(git rev-parse HEAD)
+          fi
+          # Check the tag against package metadata without importing/building it.
+          git show "$commit:pyproject.toml" > "$RUNNER_TEMP/release-project.toml"
+          RELEASE_TAG="$tag" python -c 'import os, pathlib, tomllib; data = tomllib.loads((pathlib.Path(os.environ["RUNNER_TEMP"]) / "release-project.toml").read_text()); assert os.environ["RELEASE_TAG"] == "v" + data["project"]["version"]'
+          echo "release_tag=$tag" >> "$GITHUB_OUTPUT"
+          echo "release_commit=$commit" >> "$GITHUB_OUTPUT"
+
+  distributions:
+    name: Build release distributions
+    needs: release
+    if: needs.release.outputs.tag != '' && needs.release.outputs.commit != ''
+    uses: ./.github/workflows/wheels.yml
+    with:
+      source-ref: ${{ needs.release.outputs.commit }}
+
+  publish:
+    name: Publish distributions
+    needs: [release, distributions]
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - uses: actions/download-artifact@v4
+        with:
+          name: release-distributions
+          path: dist
+      - uses: astral-sh/setup-uv@v10.0.1
+        with:
+          python-version: '3.13'
+      - name: Preserve release assets for resumable publishing
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          RELEASE_TAG: ${{ needs.release.outputs.tag }}
+        run: uv run --no-project python scripts/release-assets.py "$RELEASE_TAG" dist
+      - name: Validate the exact files to publish
+        env:
+          RELEASE_TAG: ${{ needs.release.outputs.tag }}
+        run: |
+          uv run --no-project --with packaging python scripts/check-distributions.py dist --version "${RELEASE_TAG#v}"
+          uvx twine check --strict dist/*
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true

pythonnative-0.41.0/MANIFEST.in

@@ -0,0 +1,13 @@
+global-exclude *.pyc *.pyo .DS_Store
+include scripts/cibuildwheel.toml scripts/check-distributions.py scripts/release-assets.py
+include .github/workflows/release.yml
+recursive-exclude src/pythonnative/native .build/* .gradle/* .cxx/* build/* .swiftpm/* .kotlin/*
+prune src/pythonnative/native/android/build
+prune src/pythonnative/native/android/.gradle
+prune src/pythonnative/native/android/.cxx
+prune src/pythonnative/native/ios/.build
+prune src/pythonnative/native/ios/.swiftpm
+prune src/pythonnative/native/yoga/.build
+prune src/pythonnative/templates/android_template/app/build
+prune src/pythonnative/templates/android_template/.gradle
+prune src/pythonnative/templates/ios_template/build

pythonnative-0.41.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: pythonnative
+Version: 0.41.0
+Summary: Cross-platform native UI toolkit for Android and iOS
+Author: Owen Carey
+License: MIT License
+        
+        Copyright (c) 2026 Owen Carey
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/pythonnative/pythonnative
+Project-URL: Repository, https://github.com/pythonnative/pythonnative
+Project-URL: Issues, https://github.com/pythonnative/pythonnative/issues
+Project-URL: Documentation, https://pythonnative.com/
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Provides-Extra: build
+Requires-Dist: Pillow>=10.0; extra == "build"
+Dynamic: license-file
+
+<p align="center">
+  <img src="docs/assets/banner.jpg" alt="PythonNative" width="800" />
+</p>
+
+<p align="center">
+  <em>Build native Android and iOS apps in Python.</em>
+</p>
+
+<p align="center">
+  <a href="https://github.com/pythonnative/pythonnative/actions/workflows/ci.yml"><img src="https://github.com/pythonnative/pythonnative/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
+  <a href="https://github.com/pythonnative/pythonnative/actions/workflows/release.yml"><img src="https://github.com/pythonnative/pythonnative/actions/workflows/release.yml/badge.svg" alt="Release" /></a>
+  <a href="https://pypi.org/project/pythonnative/"><img src="https://img.shields.io/pypi/v/pythonnative" alt="PyPI Version" /></a>
+  <a href="https://pypi.org/project/pythonnative/"><img src="https://img.shields.io/pypi/pyversions/pythonnative" alt="Python Versions" /></a>
+  <a href="LICENSE"><img src="https://img.shields.io/pypi/l/pythonnative" alt="License: MIT" /></a>
+  <a href="https://pythonnative.com/"><img src="https://img.shields.io/website?url=https%3A%2F%2Fpythonnative.com&label=docs" alt="Docs" /></a>
+</p>
+
+<p align="center">
+  <a href="https://pythonnative.com/">Documentation</a> ·
+  <a href="https://pythonnative.com/getting-started/">Getting Started</a> ·
+  <a href="https://pythonnative.com/examples/">Examples</a> ·
+  <a href="CONTRIBUTING.md">Contributing</a>
+</p>
+
+---
+
+## Overview
+
+PythonNative is a cross-platform toolkit for building native Android and iOS apps in Python. It provides a **declarative, React-like component model** with hooks and automatic reconciliation on top of a **native rendering core** written in Swift and Kotlin. Write function components with `use_state`, `use_effect`, and friends, just like React, and let PythonNative handle creating and updating native views.
+
+## Features
+
+- **Declarative components and hooks:** Describe native UI with Python functions, immutable elements, and typed styles. State, effects, context, and suspense boundaries follow one logical application tree across screens, overlays, and mounted list rows.
+- **Native widgets and layout:** Swift and Kotlin component managers own UIKit and Android widgets. The shared Yoga C++ engine computes layout beside the controls, using platform measurements for text and intrinsic sizes.
+- **Standard asyncio:** Components, effects, event handlers, and tasks run on a dedicated Python application thread. Native UI threads handle widgets, scrolling, and animation frames. Component-owned tasks are canceled on unmount.
+- **Incremental reconciliation:** State changes update affected component subtrees. Versioned bridge commits validate operations and acknowledge revisions; events and controlled text inputs carry identities that prevent stale updates.
+- **Native lists and navigation:** UIKit collection views and Android recycler views recycle cells for fixed or variable row sizes, grids, sections, and horizontal lists. Native navigation containers present logical screen roots while providers and component state remain in the shared Python tree.
+- **Animation and gestures:** Serialized animation graphs support timing, springs, decay, arithmetic, interpolation, and native scroll and gesture bindings. Swift and Kotlin recognize mobile gestures and update supported animation bindings without Python work on every frame.
+- **Device APIs:** Python facades expose camera, location, notifications, storage, permissions, and other native services. Test permissions and platform behavior on your deployment targets.
+- **Native extension SDK:** Python dataclasses and protocols define contracts; `pn codegen` generates props and module adapters for Swift and Kotlin. Plugins package native sources and resources, and builds verify matching contracts at startup.
+- **Development tools:** `pn start` serves the browser preview and connected mobile dev clients. Fast Refresh preserves compatible component state, while diagnostics report errors and invalid hook usage. Changes to native inputs trigger a rebuild.
+- **Browser preview:** `pn preview` runs your Python application against a browser renderer with DOM widgets, Yoga WebAssembly layout, and JavaScript animation graphs. It supports iteration on application logic and UI; fonts, platform controls, and device APIs require mobile testing.
+- **App packaging and dependency locks:** `pn run` and `pn build` stage bundled app templates, native libraries, and Python sources. Target-specific wheel locks record dependency versions and hashes for mobile builds. Binary dependencies need compatible mobile wheels; `pn deps` reports target resolution.
+
+## Quick Start
+
+### Installation
+
+Requires Python 3.13 or newer.
+
+```bash
+pip install pythonnative
+```
+
+### Usage
+
+```python
+import pythonnative as pn
+
+
+@pn.component
+def App():
+    count, set_count = pn.use_state(0)
+    return pn.Column(
+        pn.Text(f"Count: {count}", style=pn.style(font_size=24, bold=True)),
+        pn.Button(
+            "Tap me",
+            on_press=lambda: set_count(count + 1),
+        ),
+        style=pn.style(spacing=12, padding=16),
+    )
+```
+
+### Develop
+
+```bash
+pn init my-app && cd my-app
+pn preview          # dev server + browser preview with Fast Refresh
+pn run ios          # in another terminal: debug build that connects to the same server
+pn run android
+pn build ios        # standalone release artifacts
+```
+
+## Documentation
+
+Visit [pythonnative.com](https://pythonnative.com/) for the full documentation, including getting started guides, platform-specific instructions for Android and iOS, API reference, and working examples.
+
+## Contributing
+
+Contributions are welcome. Please see [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions, coding standards, and guidelines for submitting pull requests.
+
+## License
+
+[MIT](LICENSE)

pythonnative-0.41.0/README.md

@@ -0,0 +1,94 @@
+<p align="center">
+  <img src="docs/assets/banner.jpg" alt="PythonNative" width="800" />
+</p>
+
+<p align="center">
+  <em>Build native Android and iOS apps in Python.</em>
+</p>
+
+<p align="center">
+  <a href="https://github.com/pythonnative/pythonnative/actions/workflows/ci.yml"><img src="https://github.com/pythonnative/pythonnative/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
+  <a href="https://github.com/pythonnative/pythonnative/actions/workflows/release.yml"><img src="https://github.com/pythonnative/pythonnative/actions/workflows/release.yml/badge.svg" alt="Release" /></a>
+  <a href="https://pypi.org/project/pythonnative/"><img src="https://img.shields.io/pypi/v/pythonnative" alt="PyPI Version" /></a>
+  <a href="https://pypi.org/project/pythonnative/"><img src="https://img.shields.io/pypi/pyversions/pythonnative" alt="Python Versions" /></a>
+  <a href="LICENSE"><img src="https://img.shields.io/pypi/l/pythonnative" alt="License: MIT" /></a>
+  <a href="https://pythonnative.com/"><img src="https://img.shields.io/website?url=https%3A%2F%2Fpythonnative.com&label=docs" alt="Docs" /></a>
+</p>
+
+<p align="center">
+  <a href="https://pythonnative.com/">Documentation</a> ·
+  <a href="https://pythonnative.com/getting-started/">Getting Started</a> ·
+  <a href="https://pythonnative.com/examples/">Examples</a> ·
+  <a href="CONTRIBUTING.md">Contributing</a>
+</p>
+
+---
+
+## Overview
+
+PythonNative is a cross-platform toolkit for building native Android and iOS apps in Python. It provides a **declarative, React-like component model** with hooks and automatic reconciliation on top of a **native rendering core** written in Swift and Kotlin. Write function components with `use_state`, `use_effect`, and friends, just like React, and let PythonNative handle creating and updating native views.
+
+## Features
+
+- **Declarative components and hooks:** Describe native UI with Python functions, immutable elements, and typed styles. State, effects, context, and suspense boundaries follow one logical application tree across screens, overlays, and mounted list rows.
+- **Native widgets and layout:** Swift and Kotlin component managers own UIKit and Android widgets. The shared Yoga C++ engine computes layout beside the controls, using platform measurements for text and intrinsic sizes.
+- **Standard asyncio:** Components, effects, event handlers, and tasks run on a dedicated Python application thread. Native UI threads handle widgets, scrolling, and animation frames. Component-owned tasks are canceled on unmount.
+- **Incremental reconciliation:** State changes update affected component subtrees. Versioned bridge commits validate operations and acknowledge revisions; events and controlled text inputs carry identities that prevent stale updates.
+- **Native lists and navigation:** UIKit collection views and Android recycler views recycle cells for fixed or variable row sizes, grids, sections, and horizontal lists. Native navigation containers present logical screen roots while providers and component state remain in the shared Python tree.
+- **Animation and gestures:** Serialized animation graphs support timing, springs, decay, arithmetic, interpolation, and native scroll and gesture bindings. Swift and Kotlin recognize mobile gestures and update supported animation bindings without Python work on every frame.
+- **Device APIs:** Python facades expose camera, location, notifications, storage, permissions, and other native services. Test permissions and platform behavior on your deployment targets.
+- **Native extension SDK:** Python dataclasses and protocols define contracts; `pn codegen` generates props and module adapters for Swift and Kotlin. Plugins package native sources and resources, and builds verify matching contracts at startup.
+- **Development tools:** `pn start` serves the browser preview and connected mobile dev clients. Fast Refresh preserves compatible component state, while diagnostics report errors and invalid hook usage. Changes to native inputs trigger a rebuild.
+- **Browser preview:** `pn preview` runs your Python application against a browser renderer with DOM widgets, Yoga WebAssembly layout, and JavaScript animation graphs. It supports iteration on application logic and UI; fonts, platform controls, and device APIs require mobile testing.
+- **App packaging and dependency locks:** `pn run` and `pn build` stage bundled app templates, native libraries, and Python sources. Target-specific wheel locks record dependency versions and hashes for mobile builds. Binary dependencies need compatible mobile wheels; `pn deps` reports target resolution.
+
+## Quick Start
+
+### Installation
+
+Requires Python 3.13 or newer.
+
+```bash
+pip install pythonnative
+```
+
+### Usage
+
+```python
+import pythonnative as pn
+
+
+@pn.component
+def App():
+    count, set_count = pn.use_state(0)
+    return pn.Column(
+        pn.Text(f"Count: {count}", style=pn.style(font_size=24, bold=True)),
+        pn.Button(
+            "Tap me",
+            on_press=lambda: set_count(count + 1),
+        ),
+        style=pn.style(spacing=12, padding=16),
+    )
+```
+
+### Develop
+
+```bash
+pn init my-app && cd my-app
+pn preview          # dev server + browser preview with Fast Refresh
+pn run ios          # in another terminal: debug build that connects to the same server
+pn run android
+pn build ios        # standalone release artifacts
+```
+
+## Documentation
+
+Visit [pythonnative.com](https://pythonnative.com/) for the full documentation, including getting started guides, platform-specific instructions for Android and iOS, API reference, and working examples.
+
+## Contributing
+
+Contributions are welcome. Please see [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions, coding standards, and guidelines for submitting pull requests.
+
+## License
+
+[MIT](LICENSE)

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.39.0"
+version = "0.41.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }
@@ -44,6 +44,7 @@ dev = [
   "mypy>=1.10",
   "pytest>=8.0",
   "pytest-asyncio>=0.23",
+  "PyYAML>=6.0",
   "Pillow>=10.0",
   # `pn deps` and `pn run ios` shell out to `sys.executable -m pip` to
   # resolve and vendor the app's [requirements].packages for the device
@@ -93,8 +94,15 @@ license-files = ["LICENSE*"]
 [tool.setuptools.package-data]
 pythonnative = [
   "py.typed",
-  "templates/**",
-  "devserver/static/*",
+  "templates/**", "native/**", "sdk/templates/**",
+  "devserver/static/**",
+]
+
+[tool.setuptools.exclude-package-data]
+pythonnative = [
+  "**/build/**", "**/.build/**", "**/.gradle/**",
+  "**/.cxx/**", "**/.swiftpm/**", "**/.kotlin/**",
+  "**/__pycache__/**", "**/.DS_Store",
 ]
 
 [tool.ruff]
@@ -146,11 +154,11 @@ target-version = ['py313']
 # PSR stamps the new version into pyproject.toml before running this, so
 # `--upgrade-package` re-syncs only this project's own version in the lock
 # (never dependency upgrades), and the staged uv.lock lands in the release
-# commit. This also replaces the workflow's separate `python -m build`.
+# commit. The release workflow builds distributions from that tagged commit
+# using the same cibuildwheel matrix as PR CI.
 build_command = """
 uv lock --upgrade-package pythonnative
 git add uv.lock
-uv build
 """
 version_toml = ["pyproject.toml:project.version"]
 version_variables = ["src/pythonnative/__init__.py:__version__"]

pythonnative-0.41.0/scripts/check-distributions.py

@@ -0,0 +1,121 @@
+"""Reject incomplete or incorrectly tagged release artifacts before publishing."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import tarfile
+import tomllib
+import zipfile
+from email.parser import BytesParser
+from pathlib import Path
+
+from packaging.tags import parse_tag
+from packaging.utils import canonicalize_name, parse_sdist_filename, parse_wheel_filename
+from packaging.version import Version
+
+PYTHONS = {"cp313", "cp314"}
+PLATFORMS = {"linux_x86_64", "linux_aarch64", "macos_x86_64", "macos_arm64", "win_amd64"}
+PACKAGE_FILES = {
+    "pythonnative/py.typed",
+    "pythonnative/native/yoga/python.cpp",
+    "pythonnative/native/yoga/yoga/Yoga.h",
+    "pythonnative/native/yoga/yoga/YGNode.cpp",
+    "pythonnative/native/ios/Package.swift",
+    "pythonnative/templates/android_template/gradlew",
+    "pythonnative/devserver/static/yoga/binaries/yoga-wasm-base64-esm.js",
+}
+
+
+def platform_family(platform: str) -> str:
+    """Map portable wheel tags to the host targets in the release matrix."""
+    match = re.fullmatch(r"manylinux_2_(\d+)_(x86_64|aarch64)", platform)
+    if match and int(match[1]) <= 28:
+        return f"linux_{match[2]}"
+    match = re.fullmatch(r"macosx_(\d+)_(\d+)_(x86_64|arm64)", platform)
+    if match and (int(match[1]), int(match[2])) <= (11, 0):
+        return f"macos_{match[3]}"
+    if platform == "win_amd64":
+        return platform
+    raise ValueError(f"Unsupported release platform tag: {platform}")
+
+
+def check_metadata(data: bytes, version: Version) -> None:
+    """Require archive metadata to agree with the selected release."""
+    metadata = BytesParser().parsebytes(data)
+    if canonicalize_name(metadata.get("Name", "")) != "pythonnative":
+        raise ValueError("Distribution metadata has the wrong project name")
+    if metadata.get("Version") != str(version):
+        raise ValueError("Distribution metadata has the wrong version")
+
+
+def check_distributions(directory: Path, expected_version: str) -> None:
+    """Validate the full wheel matrix and its single source distribution."""
+    version = Version(expected_version)
+    expected = {(python, platform) for python in PYTHONS for platform in PLATFORMS}
+    seen: set[tuple[str, str]] = set()
+    sdists = 0
+    for path in sorted(directory.iterdir()):
+        if path.name.endswith(".whl"):
+            name, wheel_version, build, tags = parse_wheel_filename(path.name)
+            if name != "pythonnative" or wheel_version != version or build:
+                raise ValueError(f"Unexpected wheel name/version/build: {path.name}")
+            targets = set()
+            for tag in tags:
+                if tag.interpreter not in PYTHONS or tag.abi != tag.interpreter:
+                    raise ValueError(f"Unsupported Python/ABI tag: {tag}")
+                targets.add((tag.interpreter, platform_family(tag.platform)))
+            if len(targets) != 1 or targets & seen:
+                raise ValueError(f"Duplicate or ambiguous wheel target: {path.name}")
+            seen.update(targets)
+            with zipfile.ZipFile(path) as archive:
+                names = set(archive.namelist())
+                metadata_path = f"pythonnative-{version}.dist-info/METADATA"
+                check_metadata(archive.read(metadata_path), version)
+                wheel = BytesParser().parsebytes(archive.read(metadata_path.replace("METADATA", "WHEEL")))
+                archive_tags = set().union(*(parse_tag(tag) for tag in wheel.get_all("Tag", [])))
+                if wheel.get("Root-Is-Purelib") != "false" or archive_tags != tags:
+                    raise ValueError(f"Wheel metadata disagrees with binary platform tags: {path.name}")
+                suffix = ".pyd" if next(iter(targets))[1] == "win_amd64" else ".so"
+                if not any(n.startswith("pythonnative/_yoga.") and n.endswith(suffix) for n in names):
+                    raise ValueError(f"Missing compiled Yoga extension: {path.name}")
+                missing = PACKAGE_FILES - names
+                if missing:
+                    raise ValueError(f"Missing package resources in {path.name}: {sorted(missing)}")
+        elif path.name.endswith(".tar.gz"):
+            name, sdist_version = parse_sdist_filename(path.name)
+            if name != "pythonnative" or sdist_version != version:
+                raise ValueError(f"Unexpected source distribution: {path.name}")
+            sdists += 1
+            with tarfile.open(path) as archive:
+                prefix = f"pythonnative-{version}/"
+                names = set(archive.getnames())
+                required = {prefix + "src/" + name for name in PACKAGE_FILES}
+                required |= {prefix + "setup.py", prefix + "tests/test_layout.py"}
+                if missing := required - names:
+                    raise ValueError(f"Incomplete source distribution: {sorted(missing)}")
+                metadata_file = archive.extractfile(prefix + "PKG-INFO")
+                project_file = archive.extractfile(prefix + "pyproject.toml")
+                if metadata_file is None or project_file is None:
+                    raise ValueError("Source distribution is missing package metadata")
+                check_metadata(metadata_file.read(), version)
+                if tomllib.loads(project_file.read().decode())["project"]["version"] != str(version):
+                    raise ValueError("Source version disagrees with release version")
+        else:
+            raise ValueError(f"Unexpected release artifact: {path.name}")
+    if sdists != 1 or seen != expected:
+        raise ValueError(f"Incomplete release: {sdists} sdists; missing wheel targets: {sorted(expected - seen)}")
+
+
+def main() -> None:
+    """Validate release artifacts selected by the workflow."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("directory", type=Path)
+    parser.add_argument("--version", required=True)
+    args = parser.parse_args()
+    check_distributions(args.directory, args.version)
+    print(f"Validated {len(PYTHONS) * len(PLATFORMS)} wheels and one sdist for {args.version}")
+
+
+if __name__ == "__main__":
+    main()

pythonnative-0.41.0/scripts/cibuildwheel.toml

@@ -0,0 +1,27 @@
+# Kept outside pyproject.toml so the current workflow can also build an
+# existing release's unmodified sdist, including tags predating cibuildwheel.
+[tool.cibuildwheel]
+build = ["cp313-*", "cp314-*"]
+skip = ["*-musllinux*", "*-win32", "*-manylinux_i686"]
+archs = ["native"]
+test-requires = ["pytest>=8"]
+# Install the repaired wheel into a fresh environment and copy just this
+# test file to a temporary directory, outside the source checkout.
+test-sources = ["tests/test_layout.py"]
+test-command = [
+  "python -c \"import pythonnative; from importlib.metadata import version; from pathlib import Path; assert 'site-packages' in Path(pythonnative.__file__).parts; assert pythonnative.__version__ == version('pythonnative')\"",
+  "python -m pytest -q tests/test_layout.py",
+  "pn --help",
+]
+
+[tool.cibuildwheel.linux]
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"
+
+[tool.cibuildwheel.macos]
+environment = { MACOSX_DEPLOYMENT_TARGET = "11.0" }
+
+[tool.cibuildwheel.windows]
+# These flags also make v0.40.0's C API available to ctypes without patching
+# the tagged source. setup.py supplies them for future source builds.
+environment = { CL = "/D_WINDLL", LINK = "/EXPORT:pn_yoga_callback /EXPORT:pn_yoga_measure" }

pythonnative-0.41.0/scripts/release-assets.py

@@ -0,0 +1,43 @@
+"""Preserve the exact distribution bytes across retries of a PyPI upload."""
+
+import argparse
+import json
+import subprocess
+from pathlib import Path
+
+
+def sync_assets(tag: str, directory: Path) -> None:
+    """Upload new assets and reuse existing ones without overwriting releases.
+
+    Build timestamps can change archive hashes. Store files on the GitHub
+    release before publishing to PyPI, then reuse those same bytes on recovery.
+    The workflow validates the resulting directory again before publishing.
+    """
+    result = subprocess.run(
+        ["gh", "release", "view", tag, "--json", "assets"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    existing = {asset["name"] for asset in json.loads(result.stdout)["assets"]}
+    for path in sorted(directory.iterdir()):
+        if path.name in existing:
+            subprocess.run(
+                ["gh", "release", "download", tag, "--pattern", path.name, "--dir", str(directory), "--clobber"],
+                check=True,
+            )
+        else:
+            subprocess.run(["gh", "release", "upload", tag, str(path)], check=True)
+
+
+def main() -> None:
+    """Synchronize the selected release's distribution assets."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("tag")
+    parser.add_argument("directory", type=Path)
+    args = parser.parse_args()
+    sync_assets(args.tag, args.directory)
+
+
+if __name__ == "__main__":
+    main()

pythonnative-0.41.0/setup.py

@@ -0,0 +1,23 @@
+"""Build the host Yoga binding; mobile hosts compile the vendored core."""
+
+import os
+from pathlib import Path
+
+from setuptools import Extension, setup
+
+root = Path("src/pythonnative/native/yoga")
+setup(
+    ext_modules=[
+        Extension(
+            "pythonnative._yoga",
+            sources=[str(root / "python.cpp"), *map(str, sorted((root / "yoga").rglob("*.cpp")))],
+            include_dirs=[str(root)],
+            language="c++",
+            extra_compile_args=["/std:c++20"] if os.name == "nt" else ["-std=c++20"],
+            # ctypes loads Yoga's C API and our measurement callbacks from
+            # the extension DLL, not just Python's module initializer.
+            define_macros=[("_WINDLL", "1")] if os.name == "nt" else [],
+            export_symbols=["pn_yoga_callback", "pn_yoga_measure"] if os.name == "nt" else [],
+        )
+    ]
+)