nab-python 0.0.1__py3-none-any.whl

nab_python/_lockfile/pylock.py

@@ -0,0 +1,323 @@
+"""PEP 751 ``pylock.toml`` emission.
+
+Owns ``write_lock`` and ``build_pylock`` plus the
+:class:`LockInput` -> :class:`Pylock` shape conversion.  The
+per-tuple expansion path (when a universal resolve produced
+different pins for different environments) collapses into one or
+more ``Package`` entries with markers attached; the emit-time
+disjointness validation lives in
+:mod:`nab_python._lockfile.disjointness`.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import tomli_w
+
+from .._vendor.packaging.markers import Marker
+from .._vendor.packaging.pylock import (
+    Package,
+    PackageDirectory,
+    PackageSdist,
+    PackageVcs,
+    PackageWheel,
+    Pylock,
+)
+from .._vendor.packaging.specifiers import SpecifierSet
+from .._vendor.packaging.utils import canonicalize_name
+from .._vendor.packaging.version import Version
+from .disjointness import validate_marker_disjointness
+
+if TYPE_CHECKING:
+    import os
+    from collections.abc import Mapping, Sequence
+
+    from ..lockfile import (
+        LockInput,
+        PinShape,
+        SdistArtifact,
+        WheelArtifact,
+    )
+
+
+__all__ = [
+    "build_pylock",
+    "write_lock",
+]
+
+
+def write_lock(
+    lock_input: LockInput,
+    *,
+    output_path: str | os.PathLike[str] | None = None,
+) -> str:
+    """Serialise ``lock_input`` to PEP 751 TOML text.
+
+    Returns the TOML text.  When ``output_path`` is provided, also
+    writes it atomically; the caller chooses the path (PEP 751 does
+    not mandate one).
+    """
+    pylock = build_pylock(lock_input)
+    pylock.validate()
+    text = tomli_w.dumps(dict(pylock.to_dict()))
+    if output_path is not None:
+        Path(output_path).write_text(text, encoding="utf-8")
+    return text
+
+
+def build_pylock(lock_input: LockInput) -> Pylock:
+    """Build a :class:`Pylock` from the input shape.
+
+    The resolver-side data structures have already been simplified
+    when this function runs.  The remaining work is shape conversion:
+    ``Pin`` -> ``Package``, plus marker attachment from the per-tuple
+    map.
+    """
+    from ..lockfile import LOCK_VERSION
+
+    if lock_input.per_tuple_pins:
+        package_records = _build_per_tuple_packages(lock_input)
+    else:
+        package_records = [_pin_to_package(pin) for pin in lock_input.pins.values()]
+    package_records.sort(key=_package_sort_key)
+    validate_marker_disjointness(
+        package_records,
+        environments=lock_input.tuple_environments,
+        extras=lock_input.extras,
+        groups=lock_input.dependency_groups,
+    )
+    tool: dict[str, Any] | None = (
+        {"nab": lock_input.provenance.to_block()}
+        if lock_input.provenance is not None
+        else None
+    )
+    return Pylock(
+        lock_version=Version(LOCK_VERSION),
+        environments=tuple(lock_input.environments) or None,
+        requires_python=(
+            SpecifierSet(lock_input.requires_python)
+            if lock_input.requires_python
+            else None
+        ),
+        extras=(
+            tuple(canonicalize_name(e) for e in lock_input.extras)
+            if lock_input.extras
+            else None
+        ),
+        dependency_groups=(
+            tuple(lock_input.dependency_groups)
+            if lock_input.dependency_groups
+            else None
+        ),
+        default_groups=(
+            tuple(lock_input.default_groups) if lock_input.default_groups else None
+        ),
+        created_by=lock_input.created_by,
+        packages=package_records,
+        tool=tool,
+    )
+
+
+def _pin_to_package(pin: PinShape, marker: Marker | None = None) -> Package:
+    from ..lockfile import IndexPin, LocalPin, VcsPin
+
+    if isinstance(pin, IndexPin):
+        return Package(
+            name=canonicalize_name(pin.name),
+            version=Version(pin.version),
+            marker=marker,
+            requires_python=(
+                SpecifierSet(pin.requires_python) if pin.requires_python else None
+            ),
+            index=pin.index,
+            sdist=_sdist_to_package(pin.sdist) if pin.sdist else None,
+            wheels=tuple(_wheel_to_package(w) for w in pin.wheels) or None,
+        )
+    if isinstance(pin, LocalPin):
+        return Package(
+            name=canonicalize_name(pin.name),
+            version=Version(pin.version),
+            marker=marker,
+            directory=PackageDirectory(path=pin.path, editable=False),
+        )
+    if isinstance(pin, VcsPin):
+        return Package(
+            name=canonicalize_name(pin.name),
+            version=Version(pin.version),
+            marker=marker,
+            vcs=PackageVcs(
+                type="git",
+                url=pin.repo_url,
+                commit_id=pin.commit_id,
+                subdirectory=pin.subdirectory,
+            ),
+        )
+    msg = f"unknown pin shape: {pin!r}"
+    raise TypeError(msg)
+
+
+def _wheel_to_package(wheel: WheelArtifact) -> PackageWheel:
+    return PackageWheel(
+        name=wheel.filename,
+        url=wheel.url,
+        size=wheel.size,
+        hashes=dict(wheel.hashes),
+    )
+
+
+def _sdist_to_package(sdist: SdistArtifact) -> PackageSdist:
+    return PackageSdist(
+        name=sdist.filename,
+        url=sdist.url,
+        size=sdist.size,
+        hashes=dict(sdist.hashes),
+    )
+
+
+def _build_per_tuple_packages(lock_input: LockInput) -> list[Package]:
+    """Collapse per-tuple pins into Package entries with markers.
+
+    For each canonical package name:
+    * Group tuples by (version, source-shape).
+    * Emit a Package per group; the marker is the OR of the matching
+      tuples' markers.  When the group's tuples cover the entire
+      declared universe (``lock_input.tuple_markers``) the package is
+      unconditional and the marker is omitted.
+    * Within a group, the artefact sets (wheels and sdist) are
+      unioned across the contributing tuples so tuple-specific
+      wheels (e.g. cp310-manylinux vs cp311-macos) survive.
+
+    The emitted marker is the raw OR of the per-tuple marker
+    expressions; no Boolean minimisation runs.
+    """
+    out: list[Package] = []
+    by_name = _group_by_name(lock_input.per_tuple_pins)
+    total_tuples = len(lock_input.tuple_markers)
+    for per_tuple in by_name.values():
+        groups = _group_pins_by_pin(per_tuple)
+        for pins, tuple_labels in groups:
+            marker = _build_marker(tuple_labels, lock_input.tuple_markers, total_tuples)
+            out.append(_pin_to_package(_merge_pins_in_group(pins), marker))
+    # Pins only present in lock_input.pins (e.g. tuples agreed via the
+    # single-source path) emit unconditionally.
+    for canonical_name, pin in lock_input.pins.items():
+        if canonical_name not in by_name:
+            out.append(_pin_to_package(pin))
+    return out
+
+
+def _group_by_name(
+    per_tuple_pins: Mapping[str, Mapping[str, PinShape]],
+) -> dict[str, dict[str, PinShape]]:
+    """Pivot ``{tuple_label: {name: pin}}`` to ``{canonical: {label: pin}}``."""
+    out: defaultdict[str, dict[str, PinShape]] = defaultdict(dict)
+    for tuple_label, per_name in per_tuple_pins.items():
+        for raw_name, pin in per_name.items():
+            canonical = canonicalize_name(raw_name)
+            out[canonical][tuple_label] = pin
+    return out
+
+
+def _group_pins_by_pin(
+    per_tuple: dict[str, PinShape],
+) -> list[tuple[list[PinShape], list[str]]]:
+    """Bucket tuples by structural pin discriminator, keeping every pin."""
+    by_key: dict[tuple, tuple[list[PinShape], list[str]]] = {}
+    for tuple_label, pin in per_tuple.items():
+        key = _pin_discriminator(pin)
+        if key not in by_key:
+            by_key[key] = ([], [])
+        by_key[key][0].append(pin)
+        by_key[key][1].append(tuple_label)
+    return list(by_key.values())
+
+
+def _pin_discriminator(pin: PinShape) -> tuple:
+    """Return a hashable key that identifies the source + version of ``pin``."""
+    from ..lockfile import IndexPin, LocalPin, VcsPin
+
+    if isinstance(pin, IndexPin):
+        return ("index", pin.version, pin.index)
+    if isinstance(pin, LocalPin):
+        return ("local", pin.version, pin.path)
+    if isinstance(pin, VcsPin):
+        return ("vcs", pin.commit_id, pin.repo_url, pin.subdirectory or "")
+    msg = f"unknown pin shape: {pin!r}"
+    raise TypeError(msg)
+
+
+def _merge_pins_in_group(pins: list[PinShape]) -> PinShape:
+    """Combine pins sharing a discriminator into one with unioned artefacts.
+
+    For :class:`IndexPin`, accumulates every distinct wheel filename
+    across the contributing tuples and keeps the first non-``None``
+    sdist.  ``requires_python`` survives only when every tuple agreed,
+    matching :func:`_common_requires_python`'s rule.
+    Non-IndexPin shapes are already fully discriminated, so the first
+    pin is returned unchanged.
+    """
+    from ..lockfile import IndexPin
+
+    head = pins[0]
+    if not isinstance(head, IndexPin):
+        return head
+    seen_wheels: dict[str, WheelArtifact] = {}
+    sdist = head.sdist
+    requires_python_set: set[str] = set()
+    for pin in pins:
+        assert isinstance(pin, IndexPin)
+        for wheel in pin.wheels:
+            seen_wheels.setdefault(wheel.filename, wheel)
+        if sdist is None and pin.sdist is not None:
+            sdist = pin.sdist
+        if pin.requires_python is not None:
+            requires_python_set.add(pin.requires_python)
+    requires_python = (
+        next(iter(requires_python_set)) if len(requires_python_set) == 1 else None
+    )
+    return IndexPin(
+        name=head.name,
+        version=head.version,
+        index=head.index,
+        sdist=sdist,
+        wheels=tuple(seen_wheels.values()),
+        requires_python=requires_python,
+    )
+
+
+def _build_marker(
+    tuple_labels: Sequence[str],
+    tuple_markers: Mapping[str, Marker],
+    total_tuples: int,
+) -> Marker | None:
+    """Return the marker selecting ``tuple_labels``, or ``None`` if unconditional.
+
+    The package is unconditional when ``tuple_labels`` covers every
+    declared tuple in ``tuple_markers``.  Otherwise the marker is the
+    OR of the per-tuple markers.  When ``tuple_markers`` is empty the
+    caller has not declared a tuple universe and we omit the marker.
+    """
+    if total_tuples == 0 or len(tuple_labels) >= total_tuples:
+        return None
+    markers = [tuple_markers[label] for label in tuple_labels if label in tuple_markers]
+    if not markers:
+        return None
+    return _or_markers(markers)
+
+
+def _or_markers(markers: Sequence[Marker]) -> Marker:
+    """Return a Marker that evaluates True if any of ``markers`` does."""
+    if not markers:
+        msg = "_or_markers requires at least one marker"
+        raise ValueError(msg)
+    if len(markers) == 1:
+        return markers[0]
+    parts = [f"({m})" for m in markers]
+    return Marker(" or ".join(parts))
+
+
+def _package_sort_key(package: Package) -> tuple:
+    return (str(package.name), str(package.version) if package.version else "")

nab_python/_lockfile/requirements.py

@@ -0,0 +1,121 @@
+"""Pip-compatible ``requirements.txt`` rendering for a finished resolve.
+
+Produces text that pip's hash-checking mode can install (with
+``--hash=sha256:...`` lines) or a plain ``name==version`` list when
+hashes are not required.  Per-tuple resolves render as commented
+sections; pip cannot install a single requirements.txt across
+multiple ``(python, platform)`` tuples in hash-checking mode.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import os
+    from collections.abc import Mapping
+
+    from ..lockfile import IndexPin, LockInput, PinShape
+
+
+__all__ = [
+    "write_requirements_with_hashes",
+    "write_requirements_without_hashes",
+]
+
+
+def write_requirements_with_hashes(
+    lock_input: LockInput, *, output_path: str | os.PathLike[str] | None = None
+) -> str:
+    """Render ``lock_input`` as a pip-compatible requirements.txt.
+
+    Each line is ``name==version`` followed by one ``--hash=sha256:...``
+    per recorded artefact, in the format pip's hash-checking mode
+    accepts.  Local and VCS pins are emitted as ``name @ <url>`` lines
+    without hashes (pip does not hash-check those forms).  Returns the
+    text and, when ``output_path`` is provided, atomically writes it.
+    """
+    return _render_requirements(lock_input, with_hashes=True, output_path=output_path)
+
+
+def write_requirements_without_hashes(
+    lock_input: LockInput, *, output_path: str | os.PathLike[str] | None = None
+) -> str:
+    """Render ``lock_input`` as a plain ``name==version`` list.
+
+    Same shape as :func:`write_requirements_with_hashes` but without
+    the ``--hash=sha256:...`` lines.  Local and VCS pins still render
+    as ``name @ <url>``.  Returns the text and, when ``output_path``
+    is provided, atomically writes it.
+    """
+    return _render_requirements(lock_input, with_hashes=False, output_path=output_path)
+
+
+def _render_requirements(
+    lock_input: LockInput,
+    *,
+    with_hashes: bool,
+    output_path: str | os.PathLike[str] | None,
+) -> str:
+    if lock_input.per_tuple_pins:
+        text = _render_per_tuple_requirements(lock_input, with_hashes=with_hashes)
+    else:
+        lines = _render_pins(lock_input.pins, with_hashes=with_hashes)
+        text = "\n".join(lines) + "\n"
+    if output_path is not None:
+        Path(output_path).write_text(text, encoding="utf-8")
+    return text
+
+
+def _render_per_tuple_requirements(lock_input: LockInput, *, with_hashes: bool) -> str:
+    """Emit one ``# label`` block per tuple followed by that tuple's pins.
+
+    Pip cannot install a single requirements.txt across multiple
+    ``(python, platform)`` tuples in hash-checking mode, so a multi-
+    tuple resolve serialises as commented sections that callers are
+    expected to extract per environment.
+    """
+    blocks: list[str] = []
+    for label in lock_input.per_tuple_pins:
+        pins = lock_input.per_tuple_pins[label]
+        block = [f"# {label}"]
+        block.extend(_render_pins(pins, with_hashes=with_hashes))
+        blocks.append("\n".join(block))
+    return "\n\n".join(blocks) + "\n"
+
+
+def _render_pins(pins: Mapping[str, PinShape], *, with_hashes: bool) -> list[str]:
+    """Render a flat ``{name: pin}`` mapping in alphabetical order."""
+    from ..lockfile import IndexPin, LocalPin, VcsPin
+
+    lines: list[str] = []
+    for canonical in sorted(pins):
+        pin = pins[canonical]
+
+        if isinstance(pin, IndexPin):
+            lines.extend(_render_index_pin(pin, with_hashes=with_hashes))
+        elif isinstance(pin, LocalPin):
+            lines.append(f"{pin.name} @ {Path(pin.path).resolve().as_uri()}")
+        elif isinstance(pin, VcsPin):
+            lines.append(f"{pin.name} @ {pin.repo_url}")
+        else:  # pragma: no cover - exhaustive
+            msg = f"unknown pin shape: {pin!r}"
+            raise TypeError(msg)
+
+    return lines
+
+
+def _render_index_pin(pin: IndexPin, *, with_hashes: bool = True) -> list[str]:
+    if not with_hashes:
+        return [f"{pin.name}=={pin.version}"]
+    digests: list[tuple[str, str]] = []
+    if pin.sdist is not None:
+        digests.extend(pin.sdist.hashes)
+    for wheel in pin.wheels:
+        digests.extend(wheel.hashes)
+    if not digests:
+        return [f"{pin.name}=={pin.version}"]
+    parts = [f"{pin.name}=={pin.version}"]
+    parts.extend(f"--hash={algo}:{d}" for algo, d in digests)
+    return [" \\\n    ".join(parts)]

nab_python/_packaging_provider.py

@@ -0,0 +1,98 @@
+"""Provider that bridges packaging's PEP 440 types to nab-resolver."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from nab_resolver.types import Incompatibility, RangeProtocol
+
+    from ._vendor.packaging.ranges import VersionRange
+    from ._vendor.packaging.specifiers import SpecifierSet
+    from ._vendor.packaging.version import Version
+
+__all__ = [
+    "PackagingProvider",
+]
+
+
+class PackagingProvider:
+    """In-memory provider using PEP 440 versions.
+
+    Packages are strings, versions are :class:`packaging.version.Version`,
+    and dependency constraints are :class:`packaging.specifiers.SpecifierSet`,
+    converted to :class:`packaging.ranges.VersionRange` for the resolver.
+    """
+
+    def __init__(
+        self,
+        packages: dict[str, dict[Version, dict[str, SpecifierSet]]],
+    ) -> None:
+        """Create a provider from a package graph."""
+        self._packages = packages
+
+    def _get_versions(self, package: str) -> list[Version]:
+        if package not in self._packages:
+            return []
+        return sorted(self._packages[package].keys(), reverse=True)
+
+    def choose_version(
+        self, package: str, version_range: RangeProtocol[Version]
+    ) -> Version | None:
+        """Pick the newest version within the allowed range."""
+        for version in self._get_versions(package):
+            if version in version_range:
+                return version
+        return None
+
+    def get_dependencies(
+        self, package: str, version: Version
+    ) -> dict[str, VersionRange]:
+        """Convert SpecifierSet deps to VersionRange deps."""
+        raw = self._packages.get(package, {}).get(version, {})
+        return {dep: spec.to_range() for dep, spec in raw.items()}
+
+    _CONFLICT_THRESHOLD = 5
+
+    def prioritize(
+        self,
+        package: str,
+        version_range: RangeProtocol[Version],
+        conflict_counts: Mapping[str, int],
+        culprit_counts: Mapping[str, int] | None = None,
+    ) -> tuple[bool, int]:
+        """Prioritize packages for resolution order.
+
+        Returns a tuple compared with min(), so lower = decided first.
+        Packages with many conflicts are promoted so the resolver
+        discovers incompatibilities before deciding downstream packages.
+        ``culprit_counts`` is accepted for protocol compatibility but
+        not used by this provider.
+        """
+        del culprit_counts
+        promoted = conflict_counts.get(package, 0) >= self._CONFLICT_THRESHOLD
+        versions = self._get_versions(package)
+        matching = sum(1 for v in versions if v in version_range)
+        return (not promoted, matching)
+
+    def is_ready(self, package: str) -> bool:
+        """All packages are immediately decidable for this in-memory provider."""
+        del package
+        return True
+
+    def receive_partial_solution_hint(
+        self,
+        positive_ranges: Mapping[str, RangeProtocol[Version]],
+        decisions: Mapping[str, Version],
+    ) -> None:
+        """No-op: in-memory provider does not use partial solution state."""
+
+    def consume_pending_clauses(self) -> list[Incompatibility[str, Version]]:
+        """No queued clauses for this in-memory provider."""
+        return []
+
+    def consume_force_backtrack_targets(self) -> list[str]:
+        """No force-backtrack signal from this in-memory provider."""
+        return []

nab_python/_provider/__init__.py

@@ -0,0 +1 @@
+"""Internal helpers backing :mod:`nab_python.provider`."""

nab_python/_provider/build_remote.py

@@ -0,0 +1,95 @@
+"""BUILD_REMOTE path: fetch, extract, and build a remote sdist.
+
+Invoked from :func:`resolve_dynamic_sdist` when neither the
+:pep:`643` static-deps path nor the bundled ``pyproject.toml``
+fallback yields usable dependency metadata, and the effective
+:class:`~nab_python.provider.BuildPolicy` for the package is
+:attr:`~nab_python.provider.BuildPolicy.BUILD_REMOTE`.
+
+A failure here raises :class:`~nab_python.provider.UnsupportedSdistError`
+so :func:`nab_python._provider.lookahead.look_ahead_ok` can skip the
+version.  If every candidate fails the resolver surfaces the
+accumulated reasons as a no-version-satisfies error: invoking
+``BUILD_REMOTE`` does not turn a broken sdist into a usable one,
+it just turns silence into a real diagnostic.
+"""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from nab_index.client import SdistFile, WheelFile, extract_sdist_archive
+
+from .._vendor.packaging.utils import canonicalize_name
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from .._vendor.packaging.version import Version
+    from ..metadata import WheelMetadata
+    from ..provider import Provider
+
+
+def build_remote_sdist(
+    provider: Provider,
+    package: str,
+    version: Version,
+) -> WheelMetadata:
+    """Download the sdist for ``(package, version)``, extract, and build.
+
+    ``package`` is the canonical package name; ``version`` matches an
+    entry in ``provider.versions_cache``.
+    """
+    # Late imports: ``provider`` imports this module at module load.
+    from .. import build_backend
+    from ..build_backend import BuildBackendError
+    from ..provider import UnsupportedSdistError
+
+    canonical = canonicalize_name(package)
+    versions = provider.versions_cache.get(canonical, [])
+    sdist = _find_sdist(versions, version)
+    if sdist is None:
+        msg = (
+            f"{package}=={version} build-remote requested but no sdist"
+            " is available in the listing"
+        )
+        raise UnsupportedSdistError(msg)
+
+    ver_str = str(version)
+    event = provider.coordinator.request_sdist_archive(canonical, ver_str, sdist.url)
+    event.wait()
+    data = provider.coordinator.index.get_sdist_archive(canonical, ver_str)
+    if data is None:
+        msg = (
+            f"{package}=={version} build-remote requested but sdist archive"
+            f" fetch from {sdist.url} failed"
+        )
+        raise UnsupportedSdistError(msg)
+
+    with tempfile.TemporaryDirectory(prefix="nab-build-remote-") as td:
+        try:
+            source_dir = extract_sdist_archive(data, Path(td))
+        except (OSError, ValueError) as exc:
+            msg = f"{package}=={version} sdist archive could not be extracted: {exc}"
+            raise UnsupportedSdistError(msg) from exc
+        try:
+            return build_backend.extract_metadata(
+                source_dir,
+                config=provider.build_config,
+                python_version=provider.python_version,
+            )
+        except BuildBackendError as exc:
+            msg = f"{package}=={version} build-remote backend failed: {exc}"
+            raise UnsupportedSdistError(msg) from exc
+
+
+def _find_sdist(
+    versions: Sequence[tuple[Version, WheelFile | SdistFile]],
+    version: Version,
+) -> SdistFile | None:
+    for v, d in versions:
+        if v == version and isinstance(d, SdistFile):
+            return d
+    return None