kivyforge 3.0.0.dev0__py3-none-any.whl

kivyforge/lock/wheelruntime/builder.py

@@ -0,0 +1,280 @@
+"""Assemble a ``WheelRuntimeLock`` from a ``Config`` + a platform profile.
+
+Generic orchestration shared by every wheel+runtime platform: validate/resolve
+find_links, pin the runtime, resolve wheels per variant, fail-fast on any variant
+a compiled dependency does not cover, and assemble the lock. The only
+platform-specific inputs come from the ``PlatformLockProfile``.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from collections.abc import Callable
+from datetime import UTC, datetime
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+from ... import __version__
+from ...artifacts.verify import sha256_file
+from ...config.model import Config, NativeBinaryDep
+from ..find_links import (
+    FindLinksError,
+    find_links_resolution_hint,
+    resolve_find_links,
+    validate_find_links,
+    wheel_path_from_project_root,
+)
+from ..model import LockedPackage, LockedWheel, PackageDep, canonical_name
+from ..reader import compute_pyproject_sha256
+from .model import WheelRuntimeLock
+from .native_binaries import NativeBinaryResolverError, resolve_native_binaries
+from .profile import PlatformLockProfile
+from .resolver import WheelResolver, WheelResolverError
+from .runtime import RuntimeProvider, RuntimeProviderError
+
+
+class WheelRuntimeBuildError(Exception):
+    """A wheel+runtime lock build failure surfaced with an actionable message."""
+
+
+def build_wheel_runtime_lock(
+    profile: PlatformLockProfile,
+    config: Config,
+    pyproject_text: str,
+    *,
+    project_root: Path | None = None,
+    resolver: WheelResolver | None = None,
+    runtime_provider: RuntimeProvider | None = None,
+    native_binaries: tuple[NativeBinaryDep, ...] = (),
+    offline: bool = False,
+    now: datetime | None = None,
+    on_warning: Callable[[str], None] | None = None,
+) -> WheelRuntimeLock:
+    if profile.overlay(config) is None:
+        raise WheelRuntimeBuildError(profile.missing_overlay_error())
+
+    resolver = resolver or profile.wheel_resolver()
+    runtime_provider = runtime_provider or profile.runtime_provider(config)
+    root = (project_root or Path.cwd()).resolve()
+
+    python_version = profile.python_version(config)
+    variants = profile.variants(config)
+    archs = profile.archs(config)
+
+    find_links_entries = profile.find_links(config)
+    try:
+        validate_find_links(root, find_links_entries, platform=profile.platform)
+    except FindLinksError as exc:
+        raise WheelRuntimeBuildError(str(exc)) from exc
+    find_links = resolve_find_links(root, find_links_entries)
+
+    try:
+        runtime = runtime_provider.resolve(python_version, archs, offline=offline)
+    except RuntimeProviderError as exc:
+        raise WheelRuntimeBuildError(str(exc)) from exc
+
+    try:
+        locked_native_binaries = resolve_native_binaries(
+            native_binaries, project_root=root, offline=offline
+        )
+    except NativeBinaryResolverError as exc:
+        raise WheelRuntimeBuildError(str(exc)) from exc
+
+    declared_floor = profile.declared_floor(config)
+    if (
+        declared_floor
+        and runtime.floor
+        and _version_tuple(declared_floor) < _version_tuple(runtime.floor)
+    ):
+        raise WheelRuntimeBuildError(
+            profile.floor_error(declared_floor, runtime.floor, python_version)
+        )
+
+    direct = {canonical_name(_req_name(d)) for d in config.project.dependencies}
+    excluded = {canonical_name(e) for e in profile.exclude(config)} - direct
+
+    try:
+        resolved = resolver.resolve(
+            list(config.project.dependencies),
+            python_version=python_version,
+            variants=variants,
+            extra_index_urls=list(profile.extra_index_urls(config)),
+            find_links=find_links,
+            offline=offline,
+        )
+    except WheelResolverError as exc:
+        hint = find_links_resolution_hint(
+            root, find_links_entries, pip_stderr=str(exc), platform=profile.platform
+        )
+        if hint:
+            raise WheelRuntimeBuildError(f"{exc}\n{hint}") from exc
+        raise WheelRuntimeBuildError(str(exc)) from exc
+
+    packages = []
+    for rp in resolved:
+        if canonical_name(rp.name) in excluded:
+            continue
+        wheels = tuple(
+            _locked_wheel_from_resolved(profile, w, project_root=root)
+            for w in rp.wheels
+        )
+        _check_variants_complete(profile, rp.name, wheels, archs, on_warning=on_warning)
+        packages.append(
+            LockedPackage(
+                name=rp.name,
+                version=rp.version,
+                wheels=wheels,
+                requires_python=rp.requires_python,
+                dependencies=tuple(PackageDep(name=d) for d in rp.dependencies),
+                direct_requirement=canonical_name(rp.name) in direct,
+                source_index=rp.source_index,
+            )
+        )
+
+    return WheelRuntimeLock(
+        platform=profile.platform,
+        requires_python=config.project.requires_python or ">=3.15",
+        # Canonical (serializer) order so a freshly built lock compares equal to
+        # its round-tripped form; ``lock --check`` re-resolves and compares
+        # order-sensitively against the on-disk (sorted) lock.
+        packages=tuple(sorted(packages, key=lambda p: p.sort_key)),
+        python_runtime=runtime,
+        archs=archs,
+        kivyforge_version=__version__,
+        generated_at=(now or datetime.now(UTC)).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        pyproject_sha256=compute_pyproject_sha256(pyproject_text),
+        tool_kivyforge_schema_version=profile.schema_version(config),
+        native_binaries=locked_native_binaries,
+    )
+
+
+def _locked_wheel_from_resolved(
+    profile: PlatformLockProfile, w, *, project_root: Path
+) -> LockedWheel:
+    url, path = _normalize_wheel_source(profile, w.url, project_root=project_root)
+    sha256 = w.sha256
+    if not sha256 and path:
+        sha256 = sha256_file((project_root / path).resolve())
+    if not sha256:
+        raise WheelRuntimeBuildError(
+            f"could not determine SHA-256 for wheel {w.filename!r}; "
+            f"re-run lock with network access or check the vendored file."
+        )
+    return LockedWheel(
+        name=w.filename,
+        url=url,
+        path=path,
+        sha256=sha256,
+        upload_time=w.upload_time,
+        size=w.size,
+    )
+
+
+def _normalize_wheel_source(
+    profile: PlatformLockProfile, url: str, *, project_root: Path
+) -> tuple[str | None, str | None]:
+    if url.startswith(("http://", "https://")):
+        return url, None
+    if url.startswith("file:"):
+        local = Path(unquote(urlparse(url).path))
+    else:
+        local = Path(url)
+    resolved = local.resolve()
+    root = project_root.resolve()
+    try:
+        rel = wheel_path_from_project_root(root, resolved)
+    except FindLinksError as exc:
+        raise WheelRuntimeBuildError(
+            f"wheel resolved to {resolved}, which is outside the allowed "
+            f"find_links scope for project directory {root}.\n"
+            f"  {profile.wheel_scope_hint()}"
+        ) from exc
+    return None, rel
+
+
+def _check_variants_complete(
+    profile: PlatformLockProfile,
+    name: str,
+    wheels: tuple[LockedWheel, ...],
+    archs: tuple[str, ...],
+    *,
+    on_warning: Callable[[str], None] | None = None,
+) -> None:
+    """Fail fast if a compiled package is missing a required variant.
+
+    Pure-Python packages (a single ``py3-none-any`` wheel) are always complete.
+    Coverage is source-aware: a platform may decline a wheel (and/or attach a
+    non-fatal warning) based on where it came from — see
+    :meth:`PlatformLockProfile.wheel_coverage`.
+    """
+    if any(w.is_pure_python for w in wheels):
+        return
+    covered: set[str] = set()
+    for wheel in wheels:
+        wheel_archs, warning = profile.wheel_coverage(wheel, archs)
+        covered.update(wheel_archs)
+        if warning and on_warning is not None:
+            on_warning(warning)
+    missing = [a for a in archs if a not in covered]
+    if missing:
+        raise WheelRuntimeBuildError(profile.coverage_error(name, missing))
+
+
+def semantic_equal(a: WheelRuntimeLock, b: WheelRuntimeLock) -> bool:
+    """Compare two locks ignoring the volatile ``generated_at`` field."""
+    return dataclasses.replace(a, generated_at="") == dataclasses.replace(
+        b, generated_at=""
+    )
+
+
+def diff_summary(old: WheelRuntimeLock, new: WheelRuntimeLock) -> list[str]:
+    out: list[str] = []
+    old_pkgs = {canonical_name(p.name): p for p in old.packages}
+    new_pkgs = {canonical_name(p.name): p for p in new.packages}
+    for name in sorted(new_pkgs.keys() - old_pkgs.keys()):
+        out.append(f"  + {new_pkgs[name].name} {new_pkgs[name].version} (added)")
+    for name in sorted(old_pkgs.keys() - new_pkgs.keys()):
+        out.append(f"  - {old_pkgs[name].name} {old_pkgs[name].version} (removed)")
+    for name in sorted(old_pkgs.keys() & new_pkgs.keys()):
+        if old_pkgs[name].version != new_pkgs[name].version:
+            out.append(
+                f"  ~ {new_pkgs[name].name}: "
+                f"{old_pkgs[name].version} -> {new_pkgs[name].version}"
+            )
+    if old.python_runtime.version != new.python_runtime.version:
+        out.append(
+            f"  ~ python runtime: {old.python_runtime.version} -> "
+            f"{new.python_runtime.version}"
+        )
+    old_nb = {b.name: b for b in old.native_binaries}
+    new_nb = {b.name: b for b in new.native_binaries}
+    for name in sorted(new_nb.keys() - old_nb.keys()):
+        out.append(
+            f"  + native binary {new_nb[name].name} {new_nb[name].version} (added)"
+        )
+    for name in sorted(old_nb.keys() - new_nb.keys()):
+        out.append(
+            f"  - native binary {old_nb[name].name} {old_nb[name].version} (removed)"
+        )
+    for name in sorted(old_nb.keys() & new_nb.keys()):
+        o, n = old_nb[name], new_nb[name]
+        if o.version != n.version or o.sha256 != n.sha256:
+            out.append(f"  ~ native binary {n.name}: {o.version} -> {n.version}")
+    return out
+
+
+def _req_name(requirement: str) -> str:
+    from packaging.requirements import InvalidRequirement, Requirement
+
+    try:
+        return Requirement(requirement).name
+    except InvalidRequirement:
+        return requirement
+
+
+def _version_tuple(v: str) -> tuple[int, ...]:
+    parts = []
+    for chunk in v.split("."):
+        digits = "".join(c for c in chunk if c.isdigit())
+        parts.append(int(digits) if digits else 0)
+    return tuple(parts)

kivyforge/lock/wheelruntime/model.py

@@ -0,0 +1,94 @@
+"""Generic ``wheel + bundled-runtime`` lockfile model.
+
+Shared by every platform whose lock is "platform-tagged wheels plus a bundled
+CPython runtime": macOS today, and Linux/Windows/Android in later phases. Each
+such platform differs only in a small *profile* (tag construction, the arch/ABI
+variant set, and the runtime provider); the lockfile *shape* is identical, so it
+lives here once. iOS is deliberately not part of this family — its per-slice
+framework conversion, ``Python.xcframework`` runtime, and SPM extension give it a
+genuinely different lock shape.
+
+PEP 751 ``[[packages]]`` (the generic ``LockedPackage``/``LockedWheel`` from
+``kivyforge.lock.model``) plus a ``[tool.kivyforge]`` extension recording the
+arch set and the runtime pin (provider + one archive per arch).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..model import LOCK_VERSION, LockedPackage
+
+# The wheel-runtime [tool.kivyforge] extension schema version.
+TOOL_SCHEMA_VERSION = 1
+CREATED_BY = "kivyforge"
+DEFAULT_REQUIRES_PYTHON = ">=3.15"
+
+
+@dataclass(frozen=True)
+class RuntimeArtifact:
+    """One per-arch bundled Python runtime archive (pinned by URL + SHA-256).
+
+    ``arch`` is the variant identifier: a CPU architecture on desktops
+    (``arm64``/``x86_64``) or an ABI on Android (``arm64-v8a``/…).
+    """
+
+    arch: str
+    url: str
+    sha256: str
+    archive_format: str = "tar.gz"
+
+
+@dataclass(frozen=True)
+class PythonRuntime:
+    """The bundled CPython runtime pin (provider-agnostic)."""
+
+    provider: str  # e.g. "python-build-standalone"
+    version: str  # CPython version, e.g. "3.15.0"
+    artifacts: tuple[RuntimeArtifact, ...]  # one per arch in the lock
+    floor: str | None = None  # runtime's own OS floor, if the provider reports it
+
+    def artifact_for(self, arch: str) -> RuntimeArtifact | None:
+        for art in self.artifacts:
+            if art.arch == arch:
+                return art
+        return None
+
+
+@dataclass(frozen=True)
+class LockedNativeBinary:
+    """One pinned ``[tool.kivy.<platform>.native.binaries]`` entry.
+
+    A non-wheel native binary (vendor SDK dylib/so/DLL or a helper executable)
+    pinned by SHA-256. Exactly one of ``url`` (remote source) or ``path``
+    (repo-relative vendored source) is set — the ``LockedXcframework``
+    convention.
+    """
+
+    name: str
+    version: str
+    sha256: str
+    url: str | None = None
+    path: str | None = None
+
+
+@dataclass(frozen=True)
+class WheelRuntimeLock:
+    """A ``pylock.<platform>.toml`` for the wheel + bundled-runtime family."""
+
+    platform: str  # "macos" | "linux" | "windows" | "android"
+    requires_python: str
+    packages: tuple[LockedPackage, ...]
+    python_runtime: PythonRuntime
+    archs: tuple[str, ...]
+    kivyforge_version: str
+    generated_at: str
+    pyproject_sha256: str
+    tool_kivyforge_schema_version: int
+    schema_version: int = TOOL_SCHEMA_VERSION
+    lock_version: str = LOCK_VERSION
+    created_by: str = CREATED_BY
+    extras: tuple[str, ...] = ()
+    dependency_groups: tuple[str, ...] = ()
+    default_groups: tuple[str, ...] = ()
+    native_binaries: tuple[LockedNativeBinary, ...] = ()

kivyforge/lock/wheelruntime/native_binaries.py

@@ -0,0 +1,127 @@
+"""Native-binary resolver (the ``native.binaries`` channel, macos-spec).
+
+``kivyforge lock`` reads each declared ``[tool.kivy.<platform>.native.binaries]``
+entry's ``source`` (a single native binary or a ``.zip`` of several, referenced
+by URL or repo-relative path) and computes its SHA-256. Those pins land in
+``pylock.<platform>.toml`` so ``kivyforge build`` can re-fetch the artifact by
+``url``+``sha256`` (or ``path``) and stage it into the bundle's ``bin`` directory
+reproducibly.
+
+The download backend is injectable (``Downloader``) so unit tests stay hermetic
+(no network). This mirrors ``platforms/ios/lock/xcframework.py`` without the
+per-slice framework enumeration — a native binary has no slices to read.
+"""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from kivyforge.artifacts.verify import sha256_file
+from kivyforge.config.model import NativeBinaryDep
+from kivyforge.lock.find_links import FindLinksError, wheel_path_from_project_root
+
+from .model import LockedNativeBinary
+
+if TYPE_CHECKING:
+    from kivyforge.artifacts.cache import ArtifactCache
+    from kivyforge.artifacts.download import Downloader
+
+
+class NativeBinaryResolverError(Exception):
+    """A native-binary resolution failure surfaced with an actionable message."""
+
+
+def resolve_native_binaries(
+    declared: tuple[NativeBinaryDep, ...],
+    *,
+    project_root: Path,
+    downloader: Downloader | None = None,
+    cache: ArtifactCache | None = None,
+    offline: bool = False,
+) -> tuple[LockedNativeBinary, ...]:
+    """Resolve declared native binaries into SHA-256-pinned lock entries.
+
+    Returns entries sorted by ``(name, version)``. The downloader is only invoked
+    for remote (URL) sources, so a project with only vendored binaries (or none)
+    never needs network access. ``cache`` is accepted for call-site symmetry with
+    the build-time fetch path; lock resolution computes the pin from scratch.
+    """
+    if not declared:
+        return ()
+    out = [
+        _resolve_one(
+            dep, project_root=project_root, downloader=downloader, offline=offline
+        )
+        for dep in declared
+    ]
+    out.sort(key=lambda x: (x.name.lower(), x.version))
+    return tuple(out)
+
+
+def _resolve_one(
+    dep: NativeBinaryDep,
+    *,
+    project_root: Path,
+    downloader: Downloader | None,
+    offline: bool,
+) -> LockedNativeBinary:
+    is_url = dep.source.startswith(("http://", "https://"))
+    if is_url:
+        with tempfile.TemporaryDirectory(prefix="kivy-nb-lock-") as tmp:
+            archive = _download(dep, Path(tmp), downloader=downloader, offline=offline)
+            sha256 = sha256_file(archive)
+        return LockedNativeBinary(
+            name=dep.name, version=dep.version, sha256=sha256, url=dep.source
+        )
+    resolved, rel = _resolve_local(dep, project_root=project_root)
+    return LockedNativeBinary(
+        name=dep.name, version=dep.version, sha256=sha256_file(resolved), path=rel
+    )
+
+
+def _download(
+    dep: NativeBinaryDep,
+    tmpdir: Path,
+    *,
+    downloader: Downloader | None,
+    offline: bool,
+) -> Path:
+    # Imported lazily: artifacts.download imports lock.find_links, so a top-level
+    # import here would close an import cycle (lock <-> artifacts).
+    from kivyforge.artifacts.download import DownloadError, UrllibDownloader
+
+    if offline:
+        raise NativeBinaryResolverError(
+            f"native binary {dep.name!r}: cannot download {dep.source} while "
+            f"offline.\n  Re-run `kivyforge lock` with network access, or vendor "
+            f"the file and point `source` at a repo-relative path."
+        )
+    dl = downloader or UrllibDownloader()
+    filename = dep.source.rsplit("/", 1)[-1] or dep.name
+    dest = tmpdir / filename
+    try:
+        dl.fetch_to(dep.source, dest)
+    except DownloadError as exc:
+        raise NativeBinaryResolverError(f"native binary {dep.name!r}: {exc}") from exc
+    return dest
+
+
+def _resolve_local(dep: NativeBinaryDep, *, project_root: Path) -> tuple[Path, str]:
+    root = project_root.resolve()
+    resolved = (root / dep.source).resolve()
+    try:
+        rel = wheel_path_from_project_root(root, resolved)
+    except FindLinksError as exc:
+        raise NativeBinaryResolverError(
+            f"native binary {dep.name!r}: source {dep.source!r} resolves to "
+            f"{resolved}, which is outside the project directory and its parent.\n"
+            f"  Vendored native binaries must live under the project directory "
+            f"or a shared sibling directory (e.g. examples/binaries/)."
+        ) from exc
+    if not resolved.is_file():
+        raise NativeBinaryResolverError(
+            f"native binary {dep.name!r}: vendored file not found at {dep.source!r}."
+        )
+    return resolved, rel

kivyforge/lock/wheelruntime/pbs_github.py

@@ -0,0 +1,133 @@
+"""GitHub-backed python-build-standalone (PBS) release metadata lookup.
+
+PBS publishes builds as GitHub release assets on
+``astral-sh/python-build-standalone``. Each release is tagged by date and ships,
+per platform, an ``install_only`` archive plus a companion ``.sha256`` file. This
+fetcher finds the newest release providing the requested version + target triple
+and returns its download URL + pinned SHA-256. It is triple-agnostic, so macOS
+and (later) Linux share it unchanged.
+
+This is the only networked part of the runtime provider; it is exercised against
+the live API at the phase stop rather than in hermetic unit tests (which inject a
+fake ``MetadataFetcher``).
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import urllib.request
+
+from .runtime import ReleaseAsset, RuntimeProviderError
+
+_API = "https://api.github.com/repos/astral-sh/python-build-standalone"
+# Each PBS release bundles *every* supported version × platform (hundreds of
+# assets), so listing many full release objects at once makes the API 504. The
+# newest release already contains every actively-supported CPython, so we check
+# `releases/latest` first and only fall back to small paged scans for an older
+# pin. Keep the page size small for the same 504-avoidance reason.
+_LATEST_URL = f"{_API}/releases/latest"
+_RELEASES_URL = f"{_API}/releases?per_page={{per_page}}&page={{page}}"
+_PAGE_SIZE = 10
+_MAX_PAGES = 15
+
+
+class GithubPbsMetadataFetcher:
+    """Resolve a PBS asset by querying the GitHub releases API."""
+
+    def __init__(self, latest_url: str = _LATEST_URL) -> None:
+        self._latest_url = latest_url
+
+    def fetch(
+        self, version: str, target_triple: str, *, offline: bool = False
+    ) -> ReleaseAsset:
+        if offline:
+            raise RuntimeProviderError(
+                "cannot resolve a python-build-standalone runtime offline; "
+                "re-run `kivyforge lock` with network access."
+            )
+        pattern = re.compile(
+            rf"^cpython-{re.escape(version)}\+\d+-{re.escape(target_triple)}"
+            r"-install_only\.tar\.gz$"
+        )
+        for release in self._candidate_releases():
+            asset = self._match_release(release, pattern)
+            if asset is not None:
+                return asset
+        raise RuntimeProviderError(
+            f"no python-build-standalone install_only build found for CPython "
+            f"{version} ({target_triple}).\n"
+            f"  Check available versions at "
+            f"https://github.com/astral-sh/python-build-standalone/releases."
+        )
+
+    def _candidate_releases(self):
+        """Yield the latest release, then older releases page by page."""
+        yield self._get_json(self._latest_url)
+        for page in range(1, _MAX_PAGES + 1):
+            url = _RELEASES_URL.format(per_page=_PAGE_SIZE, page=page)
+            releases = self._get_json(url)
+            if not releases:
+                return
+            yield from releases
+
+    def _match_release(self, release, pattern) -> ReleaseAsset | None:
+        assets = {a["name"]: a for a in release.get("assets", [])}
+        match = next((n for n in assets if pattern.match(n)), None)
+        if match is None:
+            return None
+        url = assets[match]["browser_download_url"]
+        sha256 = self._read_sha256(assets, match, url)
+        return ReleaseAsset(url=url, sha256=sha256)
+
+    def _read_sha256(self, assets: dict, name: str, url: str) -> str:
+        """Pin the asset's SHA-256, tried most→least authoritative.
+
+        1. GitHub's asset ``digest`` field (``sha256:<hex>``) — no extra fetch.
+        2. A per-asset ``<name>.sha256`` companion.
+        3. The release-wide ``SHA256SUMS`` manifest.
+        """
+        digest = assets[name].get("digest") or ""
+        if digest.startswith("sha256:"):
+            return digest.split(":", 1)[1].strip()
+
+        companion = f"{name}.sha256"
+        if companion in assets:
+            text = self._get_text(assets[companion]["browser_download_url"])
+            return text.split()[0].strip()
+
+        if "SHA256SUMS" in assets:
+            sha = self._sha_from_manifest(
+                assets["SHA256SUMS"]["browser_download_url"], name
+            )
+            if sha is not None:
+                return sha
+
+        raise RuntimeProviderError(
+            f"python-build-standalone asset {name!r} exposes no SHA-256 (no "
+            f"digest, .sha256, or SHA256SUMS entry); cannot pin it "
+            f"reproducibly ({url})."
+        )
+
+    def _sha_from_manifest(self, url: str, name: str) -> str | None:
+        for line in self._get_text(url).splitlines():
+            parts = line.split()
+            # "<hex>  <filename>" — match the filename column exactly.
+            if len(parts) == 2 and parts[1].strip() == name:
+                return parts[0].strip()
+        return None
+
+    def _get_json(self, url: str):
+        return json.loads(self._get_text(url))
+
+    def _get_text(self, url: str) -> str:
+        req = urllib.request.Request(  # noqa: S310 — https GitHub API only
+            url, headers={"Accept": "application/vnd.github+json"}
+        )
+        try:
+            with urllib.request.urlopen(req) as resp:  # noqa: S310
+                return resp.read().decode("utf-8")
+        except (OSError, ValueError) as exc:
+            raise RuntimeProviderError(
+                f"failed to query python-build-standalone metadata ({url}): {exc}"
+            ) from exc