kivyforge 3.0.0.dev0__py3-none-any.whl

kivyforge/platforms/ios/privacy.py

@@ -0,0 +1,39 @@
+"""Generate the app-level ``PrivacyInfo.xcprivacy`` (spec 06).
+
+Either copies the user's ``[tool.kivy.ios.privacy_manifest].source`` or writes a
+minimal valid stub. This is the *app-level* manifest only; per-xcframework
+privacy manifests are the framework author's responsibility (spec 06).
+"""
+
+from __future__ import annotations
+
+import plistlib
+import shutil
+from pathlib import Path
+
+from kivyforge.config.model import Config
+
+# Minimal valid privacy manifest: declares no tracking and no collected data.
+STUB_MANIFEST: dict = {
+    "NSPrivacyTracking": False,
+    "NSPrivacyTrackingDomains": [],
+    "NSPrivacyCollectedDataTypes": [],
+    "NSPrivacyAccessedAPITypes": [],
+}
+
+
+def write_privacy_manifest(
+    config: Config, dest: str | Path, *, project_root: Path | None = None
+) -> Path:
+    dest = Path(dest)
+    source = config.ios.privacy_manifest_source if config.ios else None
+    if source:
+        root = project_root or Path.cwd()
+        src_path = (root / source).resolve()
+        if not src_path.is_file():
+            raise FileNotFoundError(f"privacy_manifest source not found: {source}")
+        shutil.copyfile(src_path, dest)
+        return dest
+    with open(dest, "wb") as f:
+        plistlib.dump(STUB_MANIFEST, f, sort_keys=True)
+    return dest

kivyforge/platforms/ios/skeleton.py

@@ -0,0 +1,165 @@
+"""Minimal valid ``project.pbxproj`` skeleton for bootstrapping (spec 06).
+
+The ``pbxproj`` library mutates an existing project; it has no from-scratch
+constructor. ``kivyforge build`` therefore parses this internal skeleton once
+(substituting the app name + bundle id) and drives all subsequent wiring —
+phases, files, build settings — through the library's API. This is *not*
+user-facing cookiecutter templating: the skeleton is an implementation detail
+and every meaningful object is added/synced programmatically afterwards.
+"""
+
+from __future__ import annotations
+
+# Stable 24-hex object IDs for the skeleton. pbxproj generates fresh IDs for
+# everything added later; these only need to be internally consistent.
+_SKELETON = """// !$*UTF8*$!
+{
+\tarchiveVersion = 1;
+\tclasses = {
+\t};
+\tobjectVersion = 56;
+\tobjects = {
+
+\t\t1A0000000000000000000001 /* Sources */ = {
+\t\t\tisa = PBXSourcesBuildPhase;
+\t\t\tbuildActionMask = 2147483647;
+\t\t\tfiles = (
+\t\t\t);
+\t\t\trunOnlyForDeploymentPostprocessing = 0;
+\t\t};
+\t\t1A0000000000000000000002 /* Frameworks */ = {
+\t\t\tisa = PBXFrameworksBuildPhase;
+\t\t\tbuildActionMask = 2147483647;
+\t\t\tfiles = (
+\t\t\t);
+\t\t\trunOnlyForDeploymentPostprocessing = 0;
+\t\t};
+\t\t1A0000000000000000000003 /* Resources */ = {
+\t\t\tisa = PBXResourcesBuildPhase;
+\t\t\tbuildActionMask = 2147483647;
+\t\t\tfiles = (
+\t\t\t);
+\t\t\trunOnlyForDeploymentPostprocessing = 0;
+\t\t};
+
+\t\t1A0000000000000000000010 /* {APP_NAME}.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "{APP_NAME}.app"; sourceTree = BUILT_PRODUCTS_DIR; };
+
+\t\t1A0000000000000000000020 = {
+\t\t\tisa = PBXGroup;
+\t\t\tchildren = (
+\t\t\t\t1A0000000000000000000021 /* Products */,
+\t\t\t);
+\t\t\tsourceTree = "<group>";
+\t\t};
+\t\t1A0000000000000000000021 /* Products */ = {
+\t\t\tisa = PBXGroup;
+\t\t\tchildren = (
+\t\t\t\t1A0000000000000000000010 /* {APP_NAME}.app */,
+\t\t\t);
+\t\t\tname = Products;
+\t\t\tsourceTree = "<group>";
+\t\t};
+
+\t\t1A0000000000000000000030 /* {APP_NAME} */ = {
+\t\t\tisa = PBXNativeTarget;
+\t\t\tbuildConfigurationList = 1A0000000000000000000040 /* Build configuration list for PBXNativeTarget */;
+\t\t\tbuildPhases = (
+\t\t\t\t1A0000000000000000000001 /* Sources */,
+\t\t\t\t1A0000000000000000000003 /* Resources */,
+\t\t\t\t1A0000000000000000000002 /* Frameworks */,
+\t\t\t);
+\t\t\tbuildRules = (
+\t\t\t);
+\t\t\tdependencies = (
+\t\t\t);
+\t\t\tname = "{APP_NAME}";
+\t\t\tproductName = "{APP_NAME}";
+\t\t\tproductReference = 1A0000000000000000000010 /* {APP_NAME}.app */;
+\t\t\tproductType = "com.apple.product-type.application";
+\t\t};
+
+\t\t1A0000000000000000000050 /* Project object */ = {
+\t\t\tisa = PBXProject;
+\t\t\tattributes = {
+\t\t\t\tLastUpgradeCheck = 2600;
+\t\t\t\tTargetAttributes = {
+\t\t\t\t};
+\t\t\t};
+\t\t\tbuildConfigurationList = 1A0000000000000000000060 /* Build configuration list for PBXProject */;
+\t\t\tcompatibilityVersion = "Xcode 14.0";
+\t\t\tdevelopmentRegion = en;
+\t\t\thasScannedForEncodings = 0;
+\t\t\tknownRegions = (
+\t\t\t\ten,
+\t\t\t\tBase,
+\t\t\t);
+\t\t\tmainGroup = 1A0000000000000000000020;
+\t\t\tproductRefGroup = 1A0000000000000000000021 /* Products */;
+\t\t\tprojectDirPath = "";
+\t\t\tprojectRoot = "";
+\t\t\ttargets = (
+\t\t\t\t1A0000000000000000000030 /* {APP_NAME} */,
+\t\t\t);
+\t\t};
+
+\t\t1A0000000000000000000041 /* Debug */ = {
+\t\t\tisa = XCBuildConfiguration;
+\t\t\tbuildSettings = {
+\t\t\t\tPRODUCT_BUNDLE_IDENTIFIER = "{BUNDLE_ID}";
+\t\t\t\tPRODUCT_NAME = "$(TARGET_NAME)";
+\t\t\t};
+\t\t\tname = Debug;
+\t\t};
+\t\t1A0000000000000000000042 /* Release */ = {
+\t\t\tisa = XCBuildConfiguration;
+\t\t\tbuildSettings = {
+\t\t\t\tPRODUCT_BUNDLE_IDENTIFIER = "{BUNDLE_ID}";
+\t\t\t\tPRODUCT_NAME = "$(TARGET_NAME)";
+\t\t\t};
+\t\t\tname = Release;
+\t\t};
+\t\t1A0000000000000000000040 /* Build configuration list for PBXNativeTarget */ = {
+\t\t\tisa = XCConfigurationList;
+\t\t\tbuildConfigurations = (
+\t\t\t\t1A0000000000000000000041 /* Debug */,
+\t\t\t\t1A0000000000000000000042 /* Release */,
+\t\t\t);
+\t\t\tdefaultConfigurationIsVisible = 0;
+\t\t\tdefaultConfigurationName = Release;
+\t\t};
+
+\t\t1A0000000000000000000061 /* Debug */ = {
+\t\t\tisa = XCBuildConfiguration;
+\t\t\tbuildSettings = {
+\t\t\t\tALWAYS_SEARCH_USER_PATHS = NO;
+\t\t\t\tSDKROOT = iphoneos;
+\t\t\t\tIPHONEOS_DEPLOYMENT_TARGET = 13.0;
+\t\t\t};
+\t\t\tname = Debug;
+\t\t};
+\t\t1A0000000000000000000062 /* Release */ = {
+\t\t\tisa = XCBuildConfiguration;
+\t\t\tbuildSettings = {
+\t\t\t\tALWAYS_SEARCH_USER_PATHS = NO;
+\t\t\t\tSDKROOT = iphoneos;
+\t\t\t\tIPHONEOS_DEPLOYMENT_TARGET = 13.0;
+\t\t\t};
+\t\t\tname = Release;
+\t\t};
+\t\t1A0000000000000000000060 /* Build configuration list for PBXProject */ = {
+\t\t\tisa = XCConfigurationList;
+\t\t\tbuildConfigurations = (
+\t\t\t\t1A0000000000000000000061 /* Debug */,
+\t\t\t\t1A0000000000000000000062 /* Release */,
+\t\t\t);
+\t\t\tdefaultConfigurationIsVisible = 0;
+\t\t\tdefaultConfigurationName = Release;
+\t\t};
+\t};
+\trootObject = 1A0000000000000000000050 /* Project object */;
+}
+"""
+
+
+def skeleton_pbxproj(app_name: str, bundle_id: str) -> str:
+    return _SKELETON.replace("{APP_NAME}", app_name).replace("{BUNDLE_ID}", bundle_id)

kivyforge/platforms/ios/sources.py

@@ -0,0 +1,63 @@
+"""Render the fixed source files and the per-project ``main_config.h`` (spec 06).
+
+Generated source layout in <app>-ios/:
+  main.m                  — trivial entry point; calls kivyforge_main()
+  kivyforge_bootstrap.h    — bootstrap public header
+  kivyforge_bootstrap.m    — dual-mode bootstrap (SDL3 for Kivy, UIKit for pure-Python)
+  main_config.h           — per-project defines (entry point, py version)
+
+Mobile window/display geometry (DPI, scale, safe area, keyboard height) is no
+longer vendored here — it ships in Kivy core as ``kivy.mobile`` (kivy/kivy#9331).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from kivyforge.config.model import Config
+
+_TEMPLATES = Path(__file__).parent / "templates"
+
+# Files that are copied verbatim from templates/ into the generated project.
+_BOOTSTRAP_FILES = ("kivyforge_bootstrap.h", "kivyforge_bootstrap.m")
+
+
+def main_m_source() -> str:
+    return (_TEMPLATES / "main.m").read_text(encoding="utf-8")
+
+
+def render_main_config_h(config: Config, *, python_version: str | None = None) -> str:
+    """Fill the main_config.h template with APP_DIR / ENTRY_POINT / py version.
+
+    ``app/`` is the symlink name inside ``<app>-ios/`` (always ``app``), so
+    APP_DIR is the bundle-relative folder name, not the user's ``app_dir`` path.
+    """
+    version = (
+        python_version
+        or (config.ios.python_version if config.ios else None)
+        or "3.15.0"
+    )
+    major_minor = ".".join(version.split(".")[:2])
+    template = (_TEMPLATES / "main_config.h.in").read_text(encoding="utf-8")
+    return (
+        template.replace("@APP_DIR@", "app")
+        .replace("@ENTRY_POINT@", config.kivy.entry_point)
+        .replace("@PYTHON_MAJOR_MINOR@", major_minor)
+    )
+
+
+def write_sources(
+    config: Config, project_dir: str | Path, *, python_version: str | None = None
+) -> tuple[Path, Path]:
+    project_dir = Path(project_dir)
+    main_m = project_dir / "main.m"
+    main_h = project_dir / "main_config.h"
+    main_m.write_text(main_m_source(), encoding="utf-8")
+    main_h.write_text(
+        render_main_config_h(config, python_version=python_version), encoding="utf-8"
+    )
+    for fname in _BOOTSTRAP_FILES:
+        (project_dir / fname).write_text(
+            (_TEMPLATES / fname).read_text(encoding="utf-8"), encoding="utf-8"
+        )
+    return main_m, main_h

kivyforge/platforms/ios/staging.py

@@ -0,0 +1,225 @@
+"""Create and maintain the ``<app>-ios/`` staging tree (spec 06)."""
+
+from __future__ import annotations
+
+import os
+import shutil
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+from kivyforge.bundle.pycompile import PycompileError, byte_compile, select_compiler
+from kivyforge.config.model import Config
+
+_APP_COPY_IGNORE = shutil.ignore_patterns("__pycache__", "*.pyc")
+
+
+class StagingError(Exception):
+    """Staging tree cannot be created (e.g. ``app_dir`` does not exist)."""
+
+
+@dataclass(frozen=True)
+class StagingLayout:
+    root: Path  # <app>-ios/
+
+    @property
+    def xcodeproj(self) -> Path:
+        return self.root / f"{self.root.name[:-4]}.xcodeproj"
+
+    @property
+    def python_xcframework(self) -> Path:
+        return self.root / "Python.xcframework"
+
+    @property
+    def frameworks(self) -> Path:
+        return self.root / "Frameworks"
+
+    @property
+    def app(self) -> Path:
+        return self.root / "app"
+
+    @property
+    def pip_deps_simulator(self) -> Path:
+        return self.root / "pip-deps-simulator"
+
+    @property
+    def pip_deps_device(self) -> Path:
+        return self.root / "pip-deps-device"
+
+    def pip_deps_for_slice(self, target: str) -> Path:
+        """Return the slice-specific pip-deps directory for *target*."""
+        return (
+            self.pip_deps_simulator if target == "simulator" else self.pip_deps_device
+        )
+
+    @property
+    def resources(self) -> Path:
+        return self.root / "Resources"
+
+
+def staging_dir_name(config: Config) -> str:
+    return f"{config.app_slug}-ios"
+
+
+def create_staging(
+    config: Config,
+    project_root: str | Path,
+    *,
+    release: bool = False,
+    python_version: str | None = None,
+    echo: Callable[[str], None] = lambda msg: None,
+) -> StagingLayout:
+    """Create the ``<app>-ios/`` tree and the ``app/`` source.
+
+    Dev builds (``release=False``, the default) get a symlink to ``app_dir``
+    (spec 06 "symlink, not copy") for fast edit-rebuild iteration — the
+    symlink is created once and refreshed only if it points somewhere other
+    than the current ``app_dir``. Release builds (``kivyforge package``) get a
+    real, disposable copy instead, so ``[tool.kivy.ios.python.build_settings]``
+    byte-compilation/stripping can run against it without ever touching the
+    user's actual source tree — *release* requires *python_version* (the
+    pinned ``Python.xcframework`` version) for that.
+    """
+    if release and python_version is None:
+        raise ValueError("create_staging(release=True) requires python_version")
+
+    project_root = Path(project_root)
+    root = project_root / staging_dir_name(config)
+    layout = StagingLayout(root=root)
+
+    for d in (
+        root,
+        layout.frameworks,
+        layout.pip_deps_device,
+        layout.pip_deps_simulator,
+        layout.resources,
+    ):
+        d.mkdir(parents=True, exist_ok=True)
+
+    if release:
+        _materialize_app_copy(layout, project_root, config, python_version, echo)
+    else:
+        _refresh_app_symlink(layout, project_root, config.kivy.app_dir)
+    return layout
+
+
+def _refresh_app_symlink(
+    layout: StagingLayout, project_root: Path, app_dir: str
+) -> None:
+    source = project_root / app_dir
+    if not source.is_dir():
+        raise StagingError(
+            f"app_dir '{app_dir}' is not an existing directory "
+            f"(looked for {source}). Create it or fix [tool.kivy].app_dir in "
+            f"pyproject.toml — it must point at your app's Python source."
+        )
+    # The symlink target is relative to <app>-ios/ (e.g. ../src).
+    target = os.path.relpath(source.resolve(), layout.root)
+    link = layout.app
+    if link.is_symlink():
+        if os.readlink(link) == target:
+            return
+        link.unlink()
+    elif link.is_dir():
+        # A real directory here is a previous release build's materialized
+        # copy (create_staging(release=True)), not foreign user data — always
+        # kivyforge-owned output at this exact path. Reclaim it for the
+        # symlink so switching back to build/run after a package works.
+        shutil.rmtree(link)
+    elif link.exists():
+        raise FileExistsError(
+            f"{link} exists and is not a symlink; remove it and re-run build."
+        )
+    link.symlink_to(target)
+
+
+def _materialize_app_copy(
+    layout: StagingLayout,
+    project_root: Path,
+    config: Config,
+    python_version: str,
+    echo: Callable[[str], None],
+) -> None:
+    source = project_root / config.kivy.app_dir
+    if not source.is_dir():
+        raise StagingError(
+            f"app_dir '{config.kivy.app_dir}' is not an existing directory "
+            f"(looked for {source}). Create it or fix [tool.kivy].app_dir in "
+            f"pyproject.toml — it must point at your app's Python source."
+        )
+    link = layout.app
+    # Always start clean: byte-compiling mutates the copy destructively
+    # (deletes .py once a .pyc exists), so a stale copy must never be reused
+    # across builds, and a leftover symlink from an earlier dev build must
+    # never be mistaken for the release copy.
+    if link.is_symlink():
+        link.unlink()
+    elif link.is_dir():
+        shutil.rmtree(link)
+    elif link.exists():
+        raise FileExistsError(
+            f"{link} exists and is neither a symlink nor a directory; remove "
+            "it and re-run build."
+        )
+    shutil.copytree(source, link, ignore=_APP_COPY_IGNORE)
+    _compile_app_copy(link, config, python_version, echo)
+
+
+def _setting_applies(value: bool | str, *, release: bool) -> bool:
+    """A ``build_settings`` tri-state resolved for the build being produced."""
+    if isinstance(value, bool):
+        return value
+    return release  # DESKTOP_RELEASE_ONLY
+
+
+def _compile_app_copy(
+    app: Path,
+    config: Config,
+    python_version: str,
+    echo: Callable[[str], None],
+) -> None:
+    """Byte-compile/strip the materialized app copy, per ``build_settings``.
+
+    Only ever called for the release copy (``release=True`` is implicit here
+    — this function is unreachable from the dev symlink path), so the
+    tri-state resolves against ``release=True`` unconditionally. Mirrors
+    ``artifacts/collect.py::_compile_pip_deps``: the Python.xcframework ships
+    no standalone interpreter to shell out to, so the compiler ladder always
+    falls to "this process's interpreter, if its CPython minor matches", or
+    degrades.
+    """
+    settings = config.ios_required.python_build_settings
+    if not _setting_applies(settings.byte_compile, release=True):
+        return
+    compiler = select_compiler(
+        staged_interpreter=Path(), native=False, python_version=python_version
+    )
+    if compiler is None:
+        message = (
+            f"this project ships CPython {python_version}, and no CPython of "
+            "that minor could be found to byte-compile with (a .pyc is only "
+            "loadable by the exact CPython minor that wrote it)"
+        )
+        if settings.byte_compile is True:
+            raise StagingError(
+                "[tool.kivy.ios.python.build_settings].byte_compile = true but "
+                f"{message}.\n"
+                "  Install a matching CPython, or set byte_compile = false."
+            )
+        echo(f"[stage] not byte-compiling app sources: {message}.")
+        return
+    strip_source = _setting_applies(settings.strip_source, release=True)
+    with_what = " ".join(compiler) if compiler else "this interpreter"
+    echo(
+        f"[stage] byte-compiling app sources with {with_what}"
+        + (" (.pyc only)" if strip_source else "")
+    )
+    try:
+        byte_compile(
+            [app], compiler=compiler, strip_source=strip_source, stripdir=app.parent
+        )
+    except PycompileError as exc:
+        raise StagingError(
+            f"{exc}\n  Fix it, or set "
+            "[tool.kivy.ios.python.build_settings].byte_compile = false."
+        ) from exc