nab-python 0.0.1__py3-none-any.whl

nab_python/universal/wheel_selection.py

@@ -0,0 +1,327 @@
+"""Predict which wheel a ``(python_version, platform_id)`` tuple would install.
+
+Universal resolution needs the install-time wheel selection answer
+without a live interpreter, so the tag set is computed from
+:class:`PlatformSpec` directly. CPython tags come from
+``packaging.tags.cpython_tags``, interpreter-agnostic tags from
+``compatible_tags``, macOS from ``mac_platforms``, and manylinux /
+musllinux are expanded from a declared glibc / musl floor. A wheel
+matches the tuple iff its parsed tags share a member with the
+tuple's compatible-tag set.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import cache, lru_cache
+from typing import TYPE_CHECKING
+
+from .._vendor.packaging import tags as ptags
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from nab_index.client import WheelFile
+
+    from .._vendor.packaging.tags import Tag
+
+
+# PEP 427: a wheel filename has at least 5 dash-separated segments
+# (name-version-pythontag-abitag-platformtag.whl), or 6 with a build tag.
+__all__ = [
+    "PlatformSpec",
+    "compatible_tags_for_tuple",
+    "select_wheel_for_tuple",
+    "wheel_compatible_with_tuple",
+]
+
+
+_MIN_WHEEL_FILENAME_PARTS = 5
+
+# Default manylinux floor: glibc 2.17 (the manylinux2014 generation,
+# adopted by every mainstream distro since CentOS 7 / Ubuntu 14.04).
+# A tighter floor reduces accepted wheels; a looser floor accepts
+# wheels that may not run on older glibc.
+_DEFAULT_MANYLINUX_FLOOR = (2, 17)
+# Default musllinux floor: musl 1.2 (adopted by Alpine 3.13+, 2021+).
+_DEFAULT_MUSLLINUX_FLOOR = (1, 2)
+# Default macOS minimum: 11 (Big Sur, 2020+).  arm64 was introduced
+# at 11.0; using 10.x for arm64 has no compatible wheels.
+_DEFAULT_MACOS_MIN = (11, 0)
+# Default macOS minimum for x86_64 builds.  10.13 was the last with
+# wide wheel coverage; newer macOS x86_64 builds rarely declare
+# below 10.13.
+_DEFAULT_MACOS_X86_64_MIN = (10, 13)
+
+
+@dataclass(frozen=True)
+class PlatformSpec:
+    """Concrete tag floors for one matrix platform_id.
+
+    Users can override the per-platform floors when their
+    deployment target requires it.  The defaults are deliberately
+    permissive (manylinux 2.17, musl 1.2, macOS 11) so most real
+    deployments work out of the box.
+
+    ``platform_release`` and ``platform_version`` set the
+    corresponding PEP 508 marker values on this platform's tuples
+    (hole 1.3 plug).  When unset, both default to the empty string,
+    which makes any kernel-version-conditioned marker
+    (``platform_release >= "5.10"``) evaluate False (the safe
+    direction: drop the gated dep) but a silent failure if the
+    target machine actually has that kernel.  Users who declare a
+    minimum target kernel get the gated deps included.
+    """
+
+    platform_id: str
+    manylinux_floor: tuple[int, int] = _DEFAULT_MANYLINUX_FLOOR
+    musllinux_floor: tuple[int, int] = _DEFAULT_MUSLLINUX_FLOOR
+    macos_min: tuple[int, int] | None = None  # arch-dependent default
+    platform_release: str = ""
+    platform_version: str = ""
+
+    @property
+    def arch(self) -> str:
+        """The architecture suffix used in platform tags."""
+        return _PLATFORM_ARCH[self.platform_id]
+
+
+# Map our matrix platform_ids to (kind, arch).  Kind is one of
+# "linux", "macos", "windows".  Used for tag generation.
+_PLATFORM_ARCH: dict[str, str] = {
+    "linux_x86_64": "x86_64",
+    "linux_aarch64": "aarch64",
+    "macos_arm64": "arm64",
+    "macos_x86_64": "x86_64",
+    "windows_amd64": "amd64",
+}
+
+_PLATFORM_KIND: dict[str, str] = {
+    "linux_x86_64": "linux",
+    "linux_aarch64": "linux",
+    "macos_arm64": "macos",
+    "macos_x86_64": "macos",
+    "windows_amd64": "windows",
+}
+
+
+def _linux_platform_tags(
+    arch: str,
+    *,
+    manylinux_floor: tuple[int, int],
+    musllinux_floor: tuple[int, int],
+) -> list[str]:
+    """Generate manylinux + musllinux + plain linux tags for an arch.
+
+    Returns the tag list in install-preference order: most-specific
+    (highest glibc/musl version) first.  Accepts every minor version
+    at or below the declared floor; this is the spec-compliant
+    interpretation of "manylinux_X_Y means glibc X.Y or older".
+
+    Note: PEP 600 says installers prefer wheels with the *highest*
+    glibc among compatible ones.  Our use case is "decide which
+    wheel a tuple would install"; the tag list ordering matches
+    that preference.
+    """
+    # manylinux_X_Y: PEP 600 form.  We accept any minor at or below
+    # the floor (a wheel built for glibc 2.5 runs on a system with
+    # glibc 2.17; a wheel built for glibc 2.34 does not).  Iterate
+    # high-to-low for preference order.
+    major, minor = manylinux_floor
+    out = [f"manylinux_{major}_{m}_{arch}" for m in range(minor, -1, -1)]
+    # Legacy aliases (PEPs 513/571/599).  These map to specific
+    # glibc versions: manylinux1=2.5, manylinux2010=2.12,
+    # manylinux2014=2.17.  We include them when they're <= floor.
+    legacy_aliases = [
+        ("manylinux1", (2, 5)),
+        ("manylinux2010", (2, 12)),
+        ("manylinux2014", (2, 17)),
+    ]
+    out.extend(
+        f"{name}_{arch}" for name, lver in legacy_aliases if lver <= manylinux_floor
+    )
+    # musllinux_X_Y: PEP 656 form.  Same accept-at-or-below rule.
+    mu_major, mu_minor = musllinux_floor
+    out.extend(f"musllinux_{mu_major}_{m}_{arch}" for m in range(mu_minor, -1, -1))
+    # Plain linux_<arch>: the most generic Linux tag.  Most installers
+    # accept this only when no manylinux/musllinux wheel is present.
+    out.append(f"linux_{arch}")
+    return out
+
+
+def _platform_tags_for_spec(spec: PlatformSpec) -> list[str]:
+    """Build the platform-tag list for ``spec`` in preference order."""
+    kind = _PLATFORM_KIND[spec.platform_id]
+    arch = spec.arch
+
+    if kind == "linux":
+        return _linux_platform_tags(
+            arch,
+            manylinux_floor=spec.manylinux_floor,
+            musllinux_floor=spec.musllinux_floor,
+        )
+
+    if kind == "macos":
+        macos_min = spec.macos_min
+        if macos_min is None:
+            macos_min = (
+                _DEFAULT_MACOS_MIN if arch == "arm64" else _DEFAULT_MACOS_X86_64_MIN
+            )
+        # mac_platforms treats the declared OS as a max and yields older too.
+        return list(ptags.mac_platforms(version=macos_min, arch=arch))
+
+    if kind == "windows":
+        return [f"win_{arch}"]
+
+    # Unreachable; PlatformSpec construction validates.
+    msg = f"Unknown platform kind: {kind}"  # pragma: no cover
+    raise ValueError(msg)  # pragma: no cover
+
+
+@cache
+def compatible_tags_for_tuple(
+    *,
+    python_version: str,
+    spec: PlatformSpec,
+) -> frozenset[Tag]:
+    """Return the full set of tags ``(python_version, spec)`` accepts.
+
+    Combines:
+
+    1. CPython-specific tags via ``packaging.tags.cpython_tags``
+       (cpXY-cpXY, cpXY-abi3 forward-compat, cpXY-none).
+    2. Interpreter-agnostic tags via ``packaging.tags.compatible_tags``
+       (pyXY-none-any, py3-none-any, etc.).
+
+    The platform list is computed by :func:`_platform_tags_for_spec`.
+    Cached on ``(python_version, spec)``: both inputs are immutable
+    (str, frozen dataclass) and the resulting set is identical across
+    every wheel-compatibility check for the same tuple, so the cache
+    skips rebuilding the same :class:`Tag` set per call.
+    """
+    major, minor = (int(p) for p in python_version.split("."))
+    py_version = (major, minor)
+    abi = f"cp{major}{minor}"
+    platforms = _platform_tags_for_spec(spec)
+    out: set[Tag] = set()
+    out.update(
+        ptags.cpython_tags(python_version=py_version, abis=[abi], platforms=platforms)
+    )
+    out.update(
+        ptags.compatible_tags(
+            python_version=py_version, interpreter=abi, platforms=platforms
+        )
+    )
+    return frozenset(out)
+
+
+@lru_cache(maxsize=4096)
+def _intern_tag(tag: Tag) -> Tag:
+    """Return a shared :class:`Tag` for ``tag``.
+
+    ``packaging.tags.parse_tag`` constructs fresh :class:`Tag` instances
+    on every call.  The set of distinct (interpreter, abi, platform)
+    triples in a single PyPI scan is small compared with the wheels
+    visited, so sharing the canonical instance collapses the duplicates.
+    ``Tag`` is immutable (``__slots__``) so the shared instance is safe.
+    """
+    return tag
+
+
+@lru_cache(maxsize=8192)
+def _parse_tag_str(tag_str: str) -> frozenset[Tag] | None:
+    """Cache ``parse_tag`` keyed on the wheel's ``python-abi-platform``.
+
+    Many distinct wheel filenames share the same tag suffix
+    (e.g. ``cp310-cp310-manylinux2014_x86_64``), so caching by tag
+    string deduplicates more aggressively than caching by filename.
+    Returns ``None`` for unparseable input.
+    """
+    try:
+        raw = ptags.parse_tag(tag_str)
+    except Exception:  # noqa: BLE001 - never trust upstream parser
+        return None
+    return frozenset(_intern_tag(t) for t in raw)
+
+
+def wheel_tag_set(filename: str) -> frozenset[Tag] | None:
+    """Parse a wheel filename into the set of tags it advertises.
+
+    Per PEP 427 the filename's last three dash-separated segments
+    are ``python-abi-platform``; per PEP 425 each can be a
+    dot-separated compressed set.  Returns ``None`` for a non-wheel
+    filename or one with too few segments.  The expensive work
+    (``parse_tag`` + Tag interning) lives in :func:`_parse_tag_str`,
+    which is cached on the suffix so wheels that share it
+    short-circuit.
+    """
+    if not filename.endswith(".whl"):
+        return None
+    stem = filename[:-4]
+    parts = stem.split("-")
+    # PEP 427: filename has 5 segments (no build tag) or 6 (with build).
+    if len(parts) < _MIN_WHEEL_FILENAME_PARTS:
+        return None
+    # The last three dash-separated segments are python-abi-platform.
+    return _parse_tag_str("-".join(parts[-3:]))
+
+
+def wheel_compatible_with_tuple(
+    wheel: WheelFile,
+    *,
+    python_version: str,
+    spec: PlatformSpec,
+) -> bool:
+    """Return True iff ``wheel`` is a candidate for the given tuple."""
+    wheel_tags = wheel_tag_set(wheel.filename)
+    if wheel_tags is None:
+        return False
+    compat = compatible_tags_for_tuple(python_version=python_version, spec=spec)
+    # ``frozenset.isdisjoint`` is a C-level builtin that beats the
+    # Python ``any(t in compat for t in wheel_tags)`` generator on
+    # the per-wheel hot loop.
+    return not wheel_tags.isdisjoint(compat)
+
+
+def select_wheel_for_tuple(
+    wheels: Iterable[WheelFile],
+    *,
+    python_version: str,
+    spec: PlatformSpec,
+) -> WheelFile | None:
+    """Pick the most-specific compatible wheel for the tuple, or None.
+
+    Implements PEP 425 preference: wheels matching earlier
+    (more-specific) tags in ``compatible_tags_for_tuple`` win over
+    those matching later (more-generic) tags.  Within the same tag
+    rank, the first wheel in input order wins.
+    """
+    compat_list = list(_compatible_tags_in_order(python_version, spec))
+    rank: dict[Tag, int] = {tag: i for i, tag in enumerate(compat_list)}
+
+    best: tuple[int, WheelFile] | None = None
+    for wheel in wheels:
+        wheel_tags = wheel_tag_set(wheel.filename)
+        if not wheel_tags:
+            continue
+        # Lowest rank index wins (most-specific tag).
+        wheel_rank = min((rank[t] for t in wheel_tags if t in rank), default=None)
+        if wheel_rank is None:
+            continue
+        if best is None or wheel_rank < best[0]:
+            best = (wheel_rank, wheel)
+    return best[1] if best is not None else None
+
+
+def _compatible_tags_in_order(python_version: str, spec: PlatformSpec) -> Iterable[Tag]:
+    """Yield compatible tags in install preference order."""
+    major, minor = (int(p) for p in python_version.split("."))
+    py_version = (major, minor)
+    abi = f"cp{major}{minor}"
+    platforms = _platform_tags_for_spec(spec)
+    yield from ptags.cpython_tags(
+        python_version=py_version, abis=[abi], platforms=platforms
+    )
+    yield from ptags.compatible_tags(
+        python_version=py_version, interpreter=abi, platforms=platforms
+    )

nab_python/workspace.py

@@ -0,0 +1,214 @@
+"""Workspace discovery for member ``pyproject.toml`` files.
+
+A "workspace" here is the ``[tool.nab.workspace]`` table on a parent
+``pyproject.toml``.  When ``nab lock`` is invoked against a member, this
+module walks up to the root, reads the members, and synthesises a
+:class:`~nab_python.provider.LocalSource` per member.  The provider then
+prefers those local sources over PyPI by canonical name, so a member
+package resolves against its in-tree source instead of being fetched
+from the index.
+
+Members are listed literally; globs are refused with an error.  Users
+coming from other tools that allow globs get a clear migration
+message.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import tomli
+
+from ._vendor.packaging.utils import canonicalize_name
+from .provider import BuildPolicy, LocalSource
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from pathlib import Path
+
+
+__all__ = [
+    "WorkspaceConfig",
+    "WorkspaceDiscoveryError",
+    "auto_promote_build_policy_for_workspace",
+    "discover_workspace_root",
+    "merge_workspace_local_sources",
+    "read_workspace_members",
+]
+
+
+logger = logging.getLogger(__name__)
+
+
+_PERMISSIVENESS = {
+    BuildPolicy.NEVER: 0,
+    BuildPolicy.BUILD_LOCAL: 1,
+    BuildPolicy.BUILD_REMOTE: 2,
+}
+
+
+class WorkspaceDiscoveryError(ValueError):
+    """Raised when a workspace member or root is structurally invalid."""
+
+
+@dataclass(frozen=True, slots=True)
+class WorkspaceConfig:
+    """Parsed ``[tool.nab.workspace]`` table.
+
+    ``members`` is the literal list of paths declared at the workspace
+    root.  No globs, no path resolution; those happen later in
+    :func:`read_workspace_members`.
+    """
+
+    members: tuple[str, ...]
+
+
+def discover_workspace_root(member_pyproject: Path) -> Path | None:
+    """Return the workspace root pyproject for ``member_pyproject``.
+
+    Walks from ``member_pyproject``'s directory upwards looking for the
+    first ``pyproject.toml`` whose ``[tool.nab.workspace]`` table is
+    present.  Returns that pyproject's path, or ``None`` when no such
+    ancestor (or self) exists.
+
+    The input ``member_pyproject`` is itself considered: a user invoking
+    ``nab lock`` on a workspace root sees discovery activate.
+    Filesystem-level errors and TOML parse errors during the walk are
+    swallowed: a malformed sibling pyproject should not prevent
+    discovery from finding a valid root above it.
+    """
+    start_dir = member_pyproject.resolve().parent
+    for parent in (start_dir, *start_dir.parents):
+        candidate = parent / "pyproject.toml"
+        if not candidate.is_file():
+            continue
+        try:
+            with candidate.open("rb") as f:
+                data = tomli.load(f)
+        except (OSError, tomli.TOMLDecodeError):
+            continue
+        if "workspace" in data.get("tool", {}).get("nab", {}):
+            return candidate
+    return None
+
+
+def read_workspace_members(root_pyproject: Path) -> tuple[LocalSource, ...]:
+    """Synthesise :class:`LocalSource` entries from a workspace root.
+
+    Reads ``[tool.nab.workspace].members`` from ``root_pyproject``.  Each
+    entry must be a literal path; any entry containing ``*``, ``?`` or
+    ``[`` raises :class:`WorkspaceDiscoveryError` with a message naming
+    the offending entry.  For every member directory the function opens
+    ``<member>/pyproject.toml`` and requires ``[project].name``;
+    missing pyproject or missing name is a hard error.
+
+    Two members declaring the same canonical name raises
+    :class:`WorkspaceDiscoveryError`.  The returned tuple preserves
+    declaration order, which makes ``nab lock`` output stable when the
+    list of members is itself stable.
+    """
+    with root_pyproject.open("rb") as f:
+        root_data = tomli.load(f)
+    raw_workspace = root_data.get("tool", {}).get("nab", {}).get("workspace")
+    if not isinstance(raw_workspace, dict):
+        msg = (
+            f"{root_pyproject}: [tool.nab.workspace] must be a table,"
+            f" got {type(raw_workspace).__name__}"
+        )
+        raise WorkspaceDiscoveryError(msg)
+    raw_members = raw_workspace.get("members")
+    if not isinstance(raw_members, list):
+        msg = (
+            f"{root_pyproject}: [tool.nab.workspace].members must be a list of"
+            f" strings, got {type(raw_members).__name__}"
+        )
+        raise WorkspaceDiscoveryError(msg)
+
+    sources: list[LocalSource] = []
+    seen: dict[str, str] = {}
+    for entry in raw_members:
+        if not isinstance(entry, str):
+            msg = (
+                f"{root_pyproject}: [tool.nab.workspace].members entries must be"
+                f" strings, got {type(entry).__name__}: {entry!r}"
+            )
+            raise WorkspaceDiscoveryError(msg)
+        if any(ch in entry for ch in "*?["):
+            msg = (
+                f"{root_pyproject}: globs in [tool.nab.workspace].members are not"
+                f" supported in nab; list members literally."
+                f"  Offending entry: {entry!r}"
+            )
+            raise WorkspaceDiscoveryError(msg)
+        member_dir = (root_pyproject.parent / entry).resolve()
+        member_pyproject = member_dir / "pyproject.toml"
+        if not member_pyproject.is_file():
+            msg = (
+                f"{root_pyproject}: workspace member {entry!r} has no"
+                f" pyproject.toml at {member_pyproject}"
+            )
+            raise WorkspaceDiscoveryError(msg)
+        with member_pyproject.open("rb") as f:
+            member_data = tomli.load(f)
+        name = member_data.get("project", {}).get("name")
+        if not isinstance(name, str) or not name:
+            msg = (
+                f"{member_pyproject}: workspace member must declare"
+                f" [project].name (got {name!r})"
+            )
+            raise WorkspaceDiscoveryError(msg)
+        canonical = canonicalize_name(name)
+        if canonical in seen:
+            msg = (
+                f"{root_pyproject}: workspace members declare duplicate"
+                f" canonical name {canonical!r} via entries {seen[canonical]!r}"
+                f" and {entry!r}"
+            )
+            raise WorkspaceDiscoveryError(msg)
+        seen[canonical] = entry
+        sources.append(LocalSource(name=name, path=str(member_dir)))
+    return tuple(sources)
+
+
+def merge_workspace_local_sources(
+    explicit: Iterable[LocalSource],
+    discovered: Iterable[LocalSource],
+) -> tuple[LocalSource, ...]:
+    """Combine explicit and workspace-discovered local sources.
+
+    Explicit ``[[tool.nab.local-sources]]`` entries always win.  When a
+    discovered member shares a canonical name with an explicit entry,
+    the discovered entry is dropped and one INFO log line records the
+    shadow so the user can audit what was overridden.  The order is
+    explicit entries first, then unshadowed discovered entries in the
+    order they were declared.
+    """
+    explicit_tuple = tuple(explicit)
+    explicit_names = {canonicalize_name(s.name) for s in explicit_tuple}
+    out = list(explicit_tuple)
+    for src in discovered:
+        if canonicalize_name(src.name) in explicit_names:
+            logger.info(
+                "workspace member %r at %s shadowed by explicit"
+                " [[tool.nab.local-sources]]",
+                src.name,
+                src.path,
+            )
+            continue
+        out.append(src)
+    return tuple(out)
+
+
+def auto_promote_build_policy_for_workspace(current: BuildPolicy) -> BuildPolicy:
+    """Floor ``current`` at :attr:`BuildPolicy.BUILD_LOCAL`.
+
+    Workspace members frequently use ``dynamic = ["version"]`` (hatch's
+    pattern) and other dynamic fields, which require the local backend
+    path.  The user's setting wins when it is already at least as
+    permissive as :attr:`BuildPolicy.BUILD_LOCAL`.
+    """
+    if _PERMISSIVENESS[current] < _PERMISSIVENESS[BuildPolicy.BUILD_LOCAL]:
+        return BuildPolicy.BUILD_LOCAL
+    return current

nab_python-0.0.1.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: nab-python
+Version: 0.0.1
+Summary: Index-backed provider, lockfile emitter, and downloader for nab
+Project-URL: Homepage, https://github.com/notatallshaw/nab
+Project-URL: Documentation, https://nab.readthedocs.io/
+Project-URL: Issues, https://github.com/notatallshaw/nab/issues
+Project-URL: Source, https://github.com/notatallshaw/nab
+Project-URL: Changelog, https://github.com/notatallshaw/nab/blob/main/CHANGELOG.md
+Author-email: Damian Shaw <damian.peter.shaw@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: build>=1.2
+Requires-Dist: installer>=0.7
+Requires-Dist: nab-index==0.0.1
+Requires-Dist: nab-resolver==0.0.1
+Requires-Dist: pyproject-hooks>=1.2
+Requires-Dist: tomli-w>=1.2
+Requires-Dist: tomli>=2.0
+Requires-Dist: typing-extensions>=4.6
+Description-Content-Type: text/markdown
+
+# nab-python
+
+The Python package index provider that drives [`nab-resolver`](https://pypi.org/project/nab-resolver/)
+for Python packages.
+
+It owns all the mechanics of how the resolver needs to interact with standards
+based Python package indexes and packages.
+
+It implements build and distribution policies to allow the user to control
+resolver and install behavior.
+
+## When to use it
+
+Use `nab-python` if you need to embed Python package resolution in
+another tool and want the resolver, provider, and lockfile emitter
+without the CLI.
+
+The API is currently under rapid experimentation, use exact version
+pinning.

nab_python-0.0.1.dist-info/RECORD

@@ -0,0 +1,71 @@
+nab_python/__init__.py,sha256=tKRFGIR13xvNEftDBxxdczeKtcrvaqcOPiYbmdyFOOs,62
+nab_python/_packaging_provider.py,sha256=-dxbaed8UoPtqxBnrOqxw2N_jPzHaQEMT1RJOoMHdRI,3435
+nab_python/_vcs_admission.py,sha256=RSFnuZZW_-amCcfh3ERrCx_bBsLLuBcFX-Gt9dVy3fY,7021
+nab_python/build_backend.py,sha256=T-KBp-VulIQATUjYvTt_hJronFceDSjvB-wZ3YHWPpw,6519
+nab_python/config.py,sha256=UuLxZ3pn4pEQBKBRkMiWNV53xu-iswG81lQ6-mpdmLc,28988
+nab_python/download.py,sha256=-wJGvpWqHSuQ2nK5cX-imC4pe6ypQDMYr8DLZy9ZauM,5398
+nab_python/fetch.py,sha256=jB5G-7glsn_DycdrjFz0fek-iCWiBJYsN5KRvq6-3XQ,31760
+nab_python/lockfile.py,sha256=OmO-owxmyWPUzwAgXhMgGphIv0hj1TeWW-hdF1sGqCs,7271
+nab_python/metadata.py,sha256=hRVP7xt6CWl2h-Sxq1F1BSilOWj4yg0AxEnPyuRWPlw,4868
+nab_python/provider.py,sha256=j9dutTZnuMMG8EFEYfUmXTiKb1Ge4FV7_sY-ET1gJKw,51256
+nab_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nab_python/requirements_file.py,sha256=t_7q1D-MUS_fH5-BLrXs4hB2txO5Iv-_b8vzmtINMsI,6327
+nab_python/resolve.py,sha256=X_8nBI14ECNfCh3bkQyFMNEfSpv7Jfdfz3ITyoA5QdY,18275
+nab_python/workspace.py,sha256=fKe4gyq09WkE1lSEXzkgYXeUKXcoW18SXOlYbVzY2hE,8006
+nab_python/_build/__init__.py,sha256=7qW6Gk8Tr8fc3xon-yZ1zW5Z1oUU-LPRpgyucso1GNc,61
+nab_python/_build/env.py,sha256=WxXMitoU2m526WFEi5NpNRgLOZkrrXuinan-uKY2uqQ,13790
+nab_python/_build/errors.py,sha256=1--kmqmqsOYg7JOgYWysAiLhGJci8Fi929NvPT1ssXw,501
+nab_python/_build/runner.py,sha256=VzCYGi6pIgd3d_06r5KXa0Ra5KXz-IPOrNkzCBynTcA,9356
+nab_python/_lockfile/__init__.py,sha256=gfbgTLr4C66nEZeaI5G5DGGo6_s_qrB2uWAo3DjXC7Q,59
+nab_python/_lockfile/builder.py,sha256=1YDp8yGXB1b-BrQ9NdoZYgjkEqs-qkQl_dp49BjhA8o,11531
+nab_python/_lockfile/disjointness.py,sha256=fOg6Fdyk_ZuIlmqqzh3XjrRvLYPnJ2IhzJBboRln6b4,8495
+nab_python/_lockfile/pylock.py,sha256=QKkbSz-Q5gJx-gl8hazhQetppPL-LRTaifFM9DtV5VU,10918
+nab_python/_lockfile/requirements.py,sha256=etDNIM-2CIq3eWF5BMY1Uafb9V5DHEKoSSfmEZrBff4,4410
+nab_python/_provider/__init__.py,sha256=FJwoSdUfrfhhXfaeJAIXQEWzY6KV4hKFNnvRkQVccfA,59
+nab_python/_provider/build_remote.py,sha256=nqQ4rzXNkWxNouAyhhDC-rPZmtSsbPOaREoAPYm4Oz4,3411
+nab_python/_provider/extras.py,sha256=SjJY33eXdF8MJ1KfIc2Hio3jxbpwaAwh7Rn4WZCEjMk,8293
+nab_python/_provider/listing.py,sha256=SWYyPyjhIOTLbKi0B2jYxNC3KVtq5-3XFct_DHtp0gY,16512
+nab_python/_provider/lookahead.py,sha256=xgX0f4h9dt2rdXZ_HmQmzXKyac2H4pDoaRMpVUqFotQ,5895
+nab_python/_provider/metadata_resolver.py,sha256=rBWyDlq61DasSMkKp0ilh_S8VBNOJ63rUO63eG6T_Qc,16727
+nab_python/_provider/priority.py,sha256=mYJHoMsoi71qTycyloWMmQ8ey00uNgBdIIkfXuar9yM,5975
+nab_python/_provider/sources.py,sha256=qWnS13DKWtXLqCh9dJkN453fjhmO1o9IUurPIB0pu6w,7382
+nab_python/_testing/__init__.py,sha256=WiMwVVwq6kg2mHFeM7JNA4-2tiXWVOPXq6YJd49vJQ0,44
+nab_python/_testing/coordinator_fake.py,sha256=C2A70zT311tF4Lkj2UO8YYhHeiAYLMtOgm7HUMToWxM,8759
+nab_python/_vendor/__init__.py,sha256=lSo_j79lhUNAEUBUs6RK5ZGyKM7NmjUhAXRmdGpRKmw,198
+nab_python/_vendor/packaging/LICENSE,sha256=ytHvW9NA1z4HS6YU0m996spceUDD2MNIUuZcSQlobEg,197
+nab_python/_vendor/packaging/LICENSE.APACHE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+nab_python/_vendor/packaging/LICENSE.BSD,sha256=tw5-m3QvHMb5SLNMFqo5_-zpQZY2S8iP8NIYDwAo-sU,1344
+nab_python/_vendor/packaging/PROVENANCE.md,sha256=HZFDXXqPVjFCIxAK2QtT16jS-STyEOBulxGbhLokR10,2725
+nab_python/_vendor/packaging/__init__.py,sha256=vwGIetD0qfqeO5zUYB3ECnspcLXICM3lnmTEqh55fJE,499
+nab_python/_vendor/packaging/_elffile.py,sha256=-sKkptYqzYw2-x3QByJa5mB4rfPWu1pxkZHRx1WAFCY,3211
+nab_python/_vendor/packaging/_manylinux.py,sha256=iF4g3wPHrxB7L7801xDd7Y9t8WvUnFPlhQXNT-GtV1I,9624
+nab_python/_vendor/packaging/_musllinux.py,sha256=f12WeQCVwYA_yEcVgaYrrnXzp3meJTHD5LS_aUDn4us,2772
+nab_python/_vendor/packaging/_parser.py,sha256=FSWddS3aQIyT4aMCTt5Wvs-O-iqVNvRFZSw7Q1FetLI,11712
+nab_python/_vendor/packaging/_structures.py,sha256=60jRbF78p8z5MKnNd6cAprgOadCJHV0DlmUmRBqFZcs,1109
+nab_python/_vendor/packaging/_tokenizer.py,sha256=VE_Lkm74DdF4as52JUfMRwKN81Lu_zSit6THmN2Ffq8,5456
+nab_python/_vendor/packaging/dependency_groups.py,sha256=XZIAVFK9uHG4RCGprmJn3VInUWMesxha_kytJuMO9eY,10218
+nab_python/_vendor/packaging/direct_url.py,sha256=eKmbDiPP1sLV4Mj_kCSZqqknrIyVO9Sr7JpF8KCjp4U,10917
+nab_python/_vendor/packaging/errors.py,sha256=6hfEYXAf8v_IF65-lFadJOMIieBP2xIKtyEXjG1nGIs,2680
+nab_python/_vendor/packaging/markers.py,sha256=bve3TML_xTL-QNpNWHrLiuTrDWmLROFUYjiC3cQKtoU,17470
+nab_python/_vendor/packaging/metadata.py,sha256=crAh0E3GVGVqPlu6EdRFsaG-Y6UYznTUqjuGKRGPv6c,38770
+nab_python/_vendor/packaging/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nab_python/_vendor/packaging/pylock.py,sha256=o3eyzUZ6DkKU2S-H2IZKZKTD4yCd0Gtw2uq_6hVjNBQ,33967
+nab_python/_vendor/packaging/ranges.py,sha256=wgoGlYIBARnpGhYXJBxyPCrUDVk3Nv0Uuz4qhaeSwWU,67300
+nab_python/_vendor/packaging/requirements.py,sha256=ijGq_2NxRpeOIto1z_RRMR8ZIvJoKZicFKxN8H4krlw,4448
+nab_python/_vendor/packaging/specifiers.py,sha256=yDSDr4prgiIkMzWkHgSGFWjBeNrMpZaTIecCXQk7HA4,41156
+nab_python/_vendor/packaging/tags.py,sha256=xegoSm6VqawLUlgIAB0WQYtKHAySYwxABTbOcBiVw_0,34234
+nab_python/_vendor/packaging/utils.py,sha256=2J6uAgU8vJDIY5Lvqj5lO54Qc2yxhkpgIdSqjTgtYho,9841
+nab_python/_vendor/packaging/version.py,sha256=daDMk4YRlKNgSiQkkIlxfmpsj_qGiWhVghgMiGUyc2M,38358
+nab_python/_vendor/packaging/licenses/__init__.py,sha256=_Jx0XRiD_58palsWnyLrLuh59ZpGCPIPXLKdZo9OJvQ,7293
+nab_python/_vendor/packaging/licenses/_spdx.py,sha256=WW7DXiyg68up_YND_wpRYlr1SHhiV4FfJLQffghhMxQ,51122
+nab_python/universal/__init__.py,sha256=eNFMbsK-jBNy1J7wAE702vI-LVXF_aaQQvX7G02ImUw,48
+nab_python/universal/matrix.py,sha256=QOrU5oM3XhrWKlYRuwjdYau9o6DOhsngmr6VN8anJ3s,8215
+nab_python/universal/provider.py,sha256=IrlMhoaCtDhjLyX7eu55Mq_lmsAEQhjzs3QLFUbC-lI,9238
+nab_python/universal/reresolve.py,sha256=GFpkpR897XD6XLBISMNlNIqSHPeUZ7SjpL0USWUDKag,11548
+nab_python/universal/resolve.py,sha256=zGhS3CPGINr1pZ3DBo6cZ4fj8SFmHOOOqzo-YVyuUug,18526
+nab_python/universal/validate.py,sha256=t0lPQieaITnQdFYMqXB4o7LDrnL-K2EhuMSso1tlzo0,16269
+nab_python/universal/wheel_selection.py,sha256=0qkwb3XgZdqOwVneO7Rfg7Rg02sNo6sUp9L1KszVHuc,12001
+nab_python-0.0.1.dist-info/METADATA,sha256=ywrCnKV7Vcjv-X-SIxmnavN5pBLwaHSocrChbTst5po,1804
+nab_python-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+nab_python-0.0.1.dist-info/licenses/LICENSE,sha256=oec5WE-g9eYDBVwbDbyKHR7_zK67vUXRoikkrsZRuJ8,1068
+nab_python-0.0.1.dist-info/RECORD,,

nab_python-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any